5. diel - Cykly vo Swift

V predchádzajúcom cvičení, Riešené úlohy k 4. lekcii Swift, sme si precvičili získané skúsenosti z predchádzajúcich lekcií.

V minulej lekcii, Riešené úlohy k 4. lekcii Swift , sme si vysvetlili podmienky. Teraz prejdeme k cyklom, po dnešnom Swift tutoriálu už budeme mať takmer kompletnú výbavu základných konštrukcií a budeme schopní tvoriť rozumné aplikácie.

Cykly

Ako už slovo cyklus napovie, niečo sa bude opakovať. Keď chceme v programe niečo urobiť 100x, určite nebudeme písať pod seba 100x ten istý kód, ale vložíme ho do cyklu. Cyklov máme niekoľko druhov, vysvetlíme si, kedy ktorý použiť. Samozrejme si ukážeme praktické príklady.

for cyklus

for cyklus má pevne stanovený počet opakovaní a umožňuje nám postupne prejsť všetky prvky nejakej skupiny. Cyklus sa spúšťa postupne pre všetky prvky danej skupiny, pričom každému takémuto behu cyklu hovoríme iterácie. Cyklus všeobecne zapíšeme nasledujúcim spôsobom:

for premenna in skupina

Najprv si ukážme ako jednoducho urobiť niečo viackrát. Ak chceme napr. 5x vykonať kód v cykle, vygenerovali by sme si rozsah čísel od 1 do 5 a tie cyklom prešli. Kód by bol nasledujúci:

for i in 1...5 {

}

Týmto sa kód cyklu vykoná 5x a premenná i bude mať postupne hodnoty od 1 do 5.

Ak poznáte for cyklus z iných jazykov, pravdepodobne ste si všimli, že vo Swift pripomína skôr tzv. Cyklus foreach.

Poďme si urobiť jednoduchý príklad, väčšina z nás určite pozná Sheldona z The Big Bang Theory. Pre tých čo nie, budeme simulovať situáciu, kedy klope na dvere svojej susedky. Vždy 3x zaklope a potom zavolá: "Penny!". Náš kód by bez cyklov vyzeral takto:

{SWIFT}
print("Knock")
print("Knock")
print("Knock")
print("Penny!")
{/SWIFT}

My ale už nič nemusíme otrocky opisovať:

{SWIFT}
for i in 1...3 {
    print("Knock")
}
print("Penny!")
{/SWIFT}

výstup:

Knock
Knock
Knock
Penny!

Cyklus prebehne 3x, spočiatku je v premennej i jedna, cyklus vypíše "Knock" a zvýši premennú i o jedna. Potom beží rovnako s dvojkou a trojkou. Teraz môžeme miesto trojky napísať do deklarácie cyklu desiatku. Príkaz sa spustí 10x bez toho aby sme písali niečo navyše. Určite vidíte, že cykly sú mocným nástrojom. Cyklus by sa dal ešte upraviť, konkrétne by sme mohli nahradiť premennú i podčiarknikom takto:

for _ in 1...3 {

}

Na fungovanie programu to nič nemení, iba dávame prehľadne najavo, že nás ona premenná nezaujíma, pretože ju nepotrebujeme. Takto sa tiež zbavíte varovanie Xcode, ktoré vás upozorní na nevyužité premenné. Práve pomocou podčiarknutia je ľahko označíte ako nepodstatné. Ide o informáciu pre vás či pre ďalšie programátorov.

Skúsme si teraz využiť to, že sa nám premenná inkrementuje. Vypíšme si čísla od jednej do desať. Pretože nebudeme chcieť, aby sa nám v konzole text vždy odřádkoval, použijeme funkciu print() s definovaným oddeľovačom, aby sa hodnoty nepísali pod seba, ale vedľa seba:

{SWIFT}
for i in 1...10 {
    print(i, terminator:" ")
}
{/SWIFT}

výsledok:

1 2 3 4 5 6 7 8 9 10

Vidíme, že riadiaci premenná má naozaj v každej iterácii (priebehu) inú hodnotu.

Teraz si vypíšeme malú násobilku (násobky čísel 1 až 10, vždy do desať). Stačí nám urobiť cyklus od 1 do 10 a premennú vždy násobiť daným číslom. Mohlo by to vyzerať asi takto:

{SWIFT}
print("Malá násobilka pomocou 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ýsledok:

Malá násobilka pomocou 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 pekne, ale stále sme toho dosť napísali. Ak vás napadlo, že v podstate robíme 10x to isté a len zvyšujeme číslo, ktorým násobíme, máte pravdu. Nič nám nebráni vložiť 2 cykly do seba:

{SWIFT}
print("Malá násobilka pomocou dvoch cyklov:")
for j in 1...10 {
    for i in 1...10 {
        print(i * j, terminator:" ")
    }
    print(" ")
}
{/SWIFT}

Pomerne zásadný rozdiel, že? Pochopiteľne nemôžeme použiť u oboch cyklov i, pretože sú vložené do seba. Premenná j nadobúda vo vonkajšom cykle hodnôt 1 až 10. V každej iterácii (rozumejte priebehu) cyklu je potom spustený ďalší cyklus s premennou i. Ten je nám už známy, vypíše násobky, v tomto prípade násobíme premennú j. Po každom behu vnútorného cyklu treba odřádkovat, to vykoná print(" ").

Urobme si ešte jeden program, na ktorom si ukážeme prácu s vonkajšou premennou. Aplikácia bude vedieť spočítať ľubovoľnú mocninu ľubovoľného čísla:

{SWIFT}
print("Mocninátor")
print("==========")
print("Zadajte základ mocniny: ")
let a = Int(readLine()!)!
print("Zadajte exponent: ")
let n = Int(readLine()!)!

var vysledek = a
for _ in 1...n-1 {
    vysledek = vysledek * a
}

print("Výsledok: \(vysledek)")
print("Ďakujem za použitia mocninátoru")
{/SWIFT}

Asi všetci tušíme, ako funguje mocnina. Pre istotu pripomeniem, že napríklad 2 ³ = 2 * 2 * 2. Teda a ⁿ spočítame tak, že n-1 krát vynásobíme číslo a číslom a. Výsledok si samozrejme musíme ukladať do premennej. Spočiatku bude mať hodnotu a a postupne sa bude v cykle pronásobovat. Ak ste to nestihli, máme tu samozrejme článok s algoritmom výpočtu ľubovoľnej mocniny. Vidíme, že naša premenná vysledek je v tele cyklu normálne prístupná. Ak si však nejakú premennú založíme v tele cyklu, po skončení cyklu zanikne a už nebude prístupná.

Mocninátor
==========
Zadajte základ mocniny:
2
Zadajte exponent:
3
Výsledok: 8
Ďakujem za použitia mocninátoru

Už tušíme, na čo sa for cyklus využíva. Zapamätajme si, že je počet opakovaní pevne daný. Premenná cyklu je v každej iterácii konštanta, takže ju ani nemôžete meniť (niektoré jazyky to umožňujú, ale vedie to k problémom).

while cyklus

Cyklus while funguje inak, jednoducho opakuje príkazy v bloku kým platí podmienka. Syntax cyklu je nasledovné:

while podmienka {
    // príkazy
}

Ak vás napadá, že možno cez while cyklus urobiť aj for cyklus, máte pravdu Cyklus while sa ale používa na trochu iné veci, často máme v jeho podmienke napr. Metódu vracajúci logickú hodnotu true / false. Pôvodný príklad z for cyklu by sme urobili pomocou while nasledovne:

{SWIFT}
var i = 1
while i <= 10 {
    print(i)
    i += 1
}
{/SWIFT}

To ale nie je ideálne použitie while cyklu. Vezmeme si našu kalkulačku z minulých lekcií a opäť ju trochu vylepšíme, konkrétne o možnosť zadať viac príkladov. Program teda hneď neskončí, ale spýta sa užívateľa, či si praje spočítať ďalší príklad. Pripomeňme si pôvodnú verziu kódu (je to tá verzia sa switch, ale pokojne použite aj tú bez neho, záleží na vás):

{SWIFT}
print("Vitajte v kalkulačke")
print("Zadajte prvé číslo:")
let a = Double(readLine()!)!
print("Zadajte druhé číslo:")
let b = Double(readLine()!)!
print("Zvoľte si operáciu:")
print("1 - sčítanie")
print("2 - odčítanie")
print("3 - násobenie")
print("4 - delenie")
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ýsledok: \(vysledek)")
} else {
    print("Neplatná voľba")
}

print("Ďakujem za použitia kalkulačky, aplikáciu ukončíte ľubovoľnou klávesou.")
{/SWIFT}

Teraz vložíme takmer celý kód do while cyklu. Našou podmienkou bude, že používateľ zadá ano, budeme teda kontrolovať obsah premennej pokracovat. Spočiatku bude táto premenná nastavená na "ano", aby sa program vôbec spustil, potom do nej necháme načítať voľbu užívateľa:

print("Vitajte v kalkulačke")
var pokracovat = "áno"
while pokracovat == "áno" {
    print("Zadajte prvé číslo:")
    let a = Double(readLine()!)!
    print("Zadajte druhé číslo:")
    let b = Double(readLine()!)!
    print("Zvoľte si operáciu:")
    print("1 - sčítanie")
    print("2 - odčítanie")
    print("3 - násobenie")
    print("4 - delenie")
    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ýsledok: \(vysledek)")
    } else {
        print("Neplatná voľba")
    }

    print("Prajete si zadať ďalší príklad? [áno/nie]")
    pokracovat = readLine()!
}
print("Ďakujem za použitia kalkulačky")

výsledok:

Vitajte v kalkulačke
Zadajte prvé číslo:
12
Zadajte druhé číslo:
128
Zvoľte si operáciu:
1 - sčítanie
2 - odčítanie
3 - násobenie
4 - delenie
1
Výsledok: 140.0
Prajete si zadať ďalší príklad? [áno/nie]
áno
Zadajte prvé číslo:
-10.5
Zadajte druhé číslo:

Naši aplikáciu možno teraz používať viackrát a je už takmer hotová. V jednej z nasledujúcich lekcií si ukážeme, ako zabezpečiť všetky vstupy od užívateľa.

Už toho vieme celkom dosť, začína to byť zábava, že? Keďže sme sa už niekoľkokrát stretli s typom Optional, vysvetlíme si v budúcej lekcii, Riešené úlohy k 5. lekcii Swift , ako funguje.

V nasledujúcom cvičení, Riešené úlohy k 5. lekcii Swift, si precvičíme nadobudnuté skúsenosti z predchádzajúcich lekcií.

Mal si s čímkoľvek problém? Stiahni si vzorovú aplikáciu nižšie a porovnaj ju so svojím projektom, chybu tak ľahko nájdeš.