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 2³ = 2 * 2 * 2. Tedy aⁿ 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š.