Lekce 5 - Cykly ve Swift
V předešlém cvičení, Řešené úlohy k 4. lekci Swift, jsme si procvičili nabyté zkušenosti z předchozích lekcí.
Nyní přejdeme k cyklům, po dnešním Swift tutoriálu již budeme mít téměř kompletní výbavu základních konstrukcí a budeme schopni tvořit rozumné aplikace.
Cykly
Jak již slovo cyklus napoví, něco se bude opakovat. Když chceme v programu něco udělat 100x, jistě nebudeme psát pod sebe 100x ten samý kód, ale vložíme ho do cyklu. Cyklů máme několik druhů, vysvětlíme si, kdy který použít. Samozřejmě si ukážeme praktické příklady.
for
cyklus
for
cyklus má pevně stanovený počet
opakování a umožňuje nám postupně projít všechny
prvky nějaké skupiny. Cyklus se spouští postupně pro všechny
prvky dané skupiny, přičemž každému takovému běhu cyklu říkáme
iterace. Cyklus obecně zapíšeme následujícím
způsobem:
for promenna in skupina
Nejprve si ukažme jak jednoduše udělat něco vícekrát. Pokud chceme
např. 5x provést kód v cyklu, vygenerovali bychom si rozsah
čísel od 1
do 5
a ty cyklem projeli. Kód by byl
následující:
for i in 1...5 { }
Tímto se kód cyklu provede 5x a proměnná i
bude mít
postupně hodnoty od 1
do 5
.
Pokud znáte for
cyklus z jiných jazyků,
pravděpodobně jste si všimli, že ve Swift připomíná spíše tzv. cyklus
foreach
.
Pojďme si udělat jednoduchý příklad, většina z nás jistě zná Sheldona z The Big Bang Theory. Pro ty co ne, budeme simulovat situaci, kdy klepe na dveře své sousedky. Vždy 3x zaklepe a poté zavolá: "Penny!". Náš kód by bez cyklů vypadal takto:
{SWIFT}
print("Knock")
print("Knock")
print("Knock")
print("Penny!")
{/SWIFT}
My ale už nic nemusíme otrocky opisovat:
{SWIFT}
for i in 1...3 {
print("Knock")
}
print("Penny!")
{/SWIFT}
Výstup:
Knock Knock Knock Penny!
Cyklus proběhne 3x, zpočátku je v proměnné i
jedna, cyklus
vypíše "Knock" a zvýší proměnnou i
o jedna. Poté běží
stejně s dvojkou a trojkou. Nyní můžeme místo trojky napsat do deklarace
cyklu desítku. Příkaz se spustí 10x aniž bychom psali něco navíc.
Určitě vidíte, že cykly jsou mocným nástrojem. Cyklus by se dal ještě
upravit, konkrétně bychom mohli nahradit proměnnou i
podtržítkem takto:
for _ in 1...3 { }
Na fungování programu to nic nemění, pouze dáváme přehledně najevo, že nás ona proměnná nezajímá, protože ji nepotřebujeme. Takto se rovněž zbavíte varování Xcode, které vás upozorní na nevyužité proměnné. Právě pomocí podtržítka je snadno označíte jako nepodstatné. Jedná se o informaci pro vás či pro další programátory.
Zkusme si nyní využít toho, že se nám proměnná inkrementuje. Vypišme
si čísla od jedné do deseti. Protože nebudeme chtít, aby se nám v konzoli
text vždy odřádkoval, použijeme funkci print()
s definovaným
oddělovačem, aby se hodnoty nepsaly pod sebe, ale vedle sebe:
{SWIFT}
for i in 1...10 {
print(i, terminator:" ")
}
{/SWIFT}
Výsledek:
1 2 3 4 5 6 7 8 9 10
Vidíme, že řídící proměnná má opravdu v každé iteraci (průběhu) jinou hodnotu.
Nyní si vypíšeme malou násobilku (násobky čísel 1 až 10, vždy do
deseti). Stačí nám udělat cyklus od 1
do 10
a
proměnnou vždy násobit daným číslem. Mohlo by to vypadat asi takto:
{SWIFT}
print("Malá násobilka pomocí cyklu:")
for i in 1...10 {
print(i, terminator:" ")
}
print(" ")
for i in 1...10 {
print(i * 2, terminator:" ")
}
print(" ")
for i in 1...10 {
print(i * 3, terminator:" ")
}
print(" ")
for i in 1...10 {
print(i * 4, terminator:" ")
}
print(" ")
for i in 1...10 {
print(i * 5, terminator:" ")
}
print(" ")
for i in 1...10 {
print(i * 6, terminator:" ")
}
print(" ")
for i in 1...10 {
print(i * 7, terminator:" ")
}
print(" ")
for i in 1...10 {
print(i * 8, terminator:" ")
}
print(" ")
for i in 1...10 {
print(i * 9, terminator:" ")
}
print(" ")
for i in 1...10 {
print(i * 10, terminator:" ")
}
{/SWIFT}
Výsledek:
Malá násobilka pomocí cyklu: 1 2 3 4 5 6 7 8 9 10 2 4 6 8 10 12 14 16 18 20 3 6 9 12 15 18 21 24 27 30 4 8 12 16 20 24 28 32 36 40 5 10 15 20 25 30 35 40 45 50 6 12 18 24 30 36 42 48 54 60 7 14 21 28 35 42 49 56 63 70 8 16 24 32 40 48 56 64 72 80 9 18 27 36 45 54 63 72 81 90 10 20 30 40 50 60 70 80 90 100
Program funguje hezky, ale pořád jsme toho dost napsali. Pokud vás napadlo, že v podstatě děláme 10x to samé a pouze zvyšujeme číslo, kterým násobíme, máte pravdu. Nic nám nebrání vložit 2 cykly do sebe:
{SWIFT}
print("Malá násobilka pomocí dvou cyklů:")
for j in 1...10 {
for i in 1...10 {
print(i * j, terminator:" ")
}
print(" ")
}
{/SWIFT}
Poměrně zásadní rozdíl, že? Pochopitelně nemůžeme použít u obou
cyklů i
, protože jsou vložené do sebe. Proměnná
j
nabývá ve vnějším cyklu hodnot 1
až
10
. V každé iteraci (rozumějte průběhu) cyklu je poté
spuštěn další cyklus s proměnnou i
. Ten je nám již známý,
vypíše násobky, v tomto případě násobíme proměnnou j
. Po
každém běhu vnitřního cyklu je třeba odřádkovat, to vykoná
print(" ")
.
Udělejme si ještě jeden program, na kterém si ukážeme práci s vnější proměnnou. Aplikace bude umět spočítat libovolnou mocninu libovolného čísla:
{SWIFT}
print("Mocninátor")
print("==========")
print("Zadejte základ mocniny: ")
let a = Int(readLine()!)!
print("Zadejte exponent: ")
let n = Int(readLine()!)!
var vysledek = a
for _ in 1...n-1 {
vysledek = vysledek * a
}
print("Výsledek: \(vysledek)")
print("Děkuji za použití mocninátoru")
{/SWIFT}
Asi všichni tušíme, jak funguje mocnina. Pro jistotu připomenu, že
například 23 = 2 * 2 * 2. Tedy an spočítáme tak, že
n-1 krát vynásobíme číslo a
číslem a
. Výsledek
si samozřejmě musíme ukládat do proměnné. Zpočátku bude mít hodnotu
a
a postupně se bude v cyklu pronásobovat. Pokud jste to
nestihli, máme tu samozřejmě článek s
algoritmem výpočtu libovolné mocniny. Vidíme, že naše proměnná
vysledek
je v těle cyklu normálně přístupná. Pokud si však
nějakou proměnnou založíme v těle cyklu, po skončení cyklu zanikne a již
nebude přístupná.
Mocninátor ========== Zadejte základ mocniny: 2 Zadejte exponent: 3 Výsledek: 8 Děkuji za použití mocninátoru
Už tušíme, k čemu se for
cyklus využívá. Zapamatujme si,
že je počet opakování pevně daný. Proměnná cyklu je v
každé iteraci konstanta, takže ji ani nemůžete měnit (některé jazyky to
umožňují, ale vede to k problémům).
while
cyklus
Cyklus while
funguje jinak, jednoduše opakuje příkazy v bloku
dokud platí podmínka. Syntaxe cyklu je následující:
while podminka { // příkazy }
Pokud vás napadá, že lze přes while
cyklus udělat i
for
cyklus, máte pravdu Cyklus while
se ale používá na trochu jiné věci,
často máme v jeho podmínce např. metodu vracející logickou hodnotu
true
/false
. Původní příklad z for
cyklu bychom udělali pomocí while
následovně:
{SWIFT}
var i = 1
while i <= 10 {
print(i)
i += 1
}
{/SWIFT}
To ale není ideální použití while
cyklu. Vezmeme si naši
kalkulačku z minulých lekcí a opět ji trochu vylepšíme, konkrétně o
možnost zadat více příkladů. Program tedy hned neskončí, ale zeptá se
uživatele, zda si přeje spočítat další příklad. Připomeňme si
původní verzi kódu (je to ta verze se switch
, ale klidně
použijte i tu bez něj, záleží na vás):
{SWIFT}
print("Vítejte v kalkulačce")
print("Zadejte první číslo:")
let a = Double(readLine()!)!
print("Zadejte druhé číslo:")
let b = Double(readLine()!)!
print("Zvolte si operaci:")
print("1 - sčítání")
print("2 - odčítání")
print("3 - násobení")
print("4 - dělení")
let volba = Int(readLine()!)!
var vysledek : Double = 0
switch (volba) {
case 1:
vysledek = a + b
case 2:
vysledek = a - b
case 3:
vysledek = a * b
case 4:
vysledek = a / b
default:
break
}
if (volba > 0) && (volba < 5) {
print("Výsledek: \(vysledek)")
} else {
print("Neplatná volba")
}
print("Děkuji za použití kalkulačky, aplikaci ukončíte libovolnou klávesou.")
{/SWIFT}
Nyní vložíme téměř celý kód do while
cyklu. Naší
podmínkou bude, že uživatel zadá ano
, budeme tedy kontrolovat
obsah proměnné pokracovat
. Zpočátku bude tato proměnná
nastavena na "ano"
, aby se program vůbec spustil, poté do ní
necháme načíst volbu uživatele:
print("Vítejte v kalkulačce") var pokracovat = "ano" while pokracovat == "ano" { print("Zadejte první číslo:") let a = Double(readLine()!)! print("Zadejte druhé číslo:") let b = Double(readLine()!)! print("Zvolte si operaci:") print("1 - sčítání") print("2 - odčítání") print("3 - násobení") print("4 - dělení") let volba = Int(readLine()!)! var vysledek : Double = 0 switch (volba) { case 1: vysledek = a + b case 2: vysledek = a - b case 3: vysledek = a * b case 4: vysledek = a / b default: break } if (volba > 0) && (volba < 5) { print("Výsledek: \(vysledek)") } else { print("Neplatná volba") } print("Přejete si zadat další příklad? [ano/ne]") pokracovat = readLine()! } print("Děkuji za použití kalkulačky")
Výsledek:
Vítejte v kalkulačce Zadejte první číslo: 12 Zadejte druhé číslo: 128 Zvolte si operaci: 1 - sčítání 2 - odčítání 3 - násobení 4 - dělení 1 Výsledek: 140.0 Přejete si zadat další příklad? [ano/ne] ano Zadejte první číslo: -10.5 Zadejte druhé číslo:
Naši aplikaci lze nyní používat vícekrát a je již téměř hotová. V jedné z příštích lekcí si ukážeme, jak zabezpečit všechny vstupy od uživatele.
Již toho umíme docela dost, začíná to být zábava, že?
V následujícím cvičení, Řešené úlohy k 5. lekci Swift, si procvičíme nabyté zkušenosti z předchozích lekcí.
Měl jsi s čímkoli problém? Stáhni si vzorovou aplikaci níže a porovnej ji se svým projektem, chybu tak snadno najdeš.
Stáhnout
Stažením následujícího souboru souhlasíš s licenčními podmínkami
Staženo 29x (128.96 kB)
Aplikace je včetně zdrojových kódů v jazyce Swift