Lekce 5 - Cykly v Kotlin

V předešlém cvičení, Řešené úlohy k 4. lekci Kotlin, jsme si procvičili nabyté zkušenosti z předchozích lekcí.

Nyní přejdeme k cyklům. Po dnešním Kotlin 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 objektů. 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 projely. 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 v Kotlin 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:

{KOTLIN_CONSOLE}
println("Knock")
println("Knock")
println("Knock")
println("Penny!")
{/KOTLIN_CONSOLE}

My ale už nic nemusíme otrocky opisovat:

{KOTLIN_CONSOLE}
for (i in 1..3) {
    println("Knock")
}
println("Penny!")
{/KOTLIN_CONSOLE}

Výsledek:

Knock
Knock
Knock
Penny!

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().

{KOTLIN_CONSOLE}
for (i in 1..10) {
    print("$i ")
}
{/KOTLIN_CONSOLE}

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:

{KOTLIN_CONSOLE}
println("Malá násobilka pomocí cyklů:")
for (i in 1..10) {
    print("$i ")
}
println()
for (i in 1..10) {
    print("${i * 2} ")
}
println()
for (i in 1..10) {
    print("${i * 3} ")
}
println()
for (i in 1..10) {
    print("${i * 4} ")
}
println()
for (i in 1..10) {
    print("${i * 5} ")
}
println()
for (i in 1..10) {
    print("${i * 6} ")
}
println()
for (i in 1..10) {
    print("${i * 7} ")
}
println()
for (i in 1..10) {
    print("${i * 8} ")
}
println()
for (i in 1..10) {
    print("${i * 9} ")
}
println()
for (i in 1..10) {
    print("${i * 10} ")
}
{/KOTLIN_CONSOLE}

Výstup programu:

Malá násobilka pomocí cyklů:
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:

{KOTLIN_CONSOLE}
println("Malá násobilka pomocí dvou cyklů:")
for (i in 1..10) {
    for (j in 1..10) {
        print("${i * j} ")
    }
    println()
}
{/KOTLIN_CONSOLE}

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á println().

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:

{KOTLIN_CONSOLE}
println("Mocninátor")
println("==========")
println("Zadejte základ mocniny: ")
val a = readLine()!!.toInt()
println("Zadejte exponent: ")
val n = readLine()!!.toInt()
var vysledek = a
for (i in 1..n-1) {
    vysledek = vysledek * a
}
println("Výsledek: $vysledek")
println("Děkuji za použití mocninátoru")
{/KOTLIN_CONSOLE}

Asi všichni tušíme, jak funguje mocnina. Pro jistotu připomenu, že například 2^3 = 2 * 2 * 2. Tedy a^n 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 for je vlastně speciální případ while cyklu. 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ě:

{KOTLIN_CONSOLE}
var i = 1
while (i <= 10) {
    println(i)
    i += 1
}
{/KOTLIN_CONSOLE}

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 s when, ale klidně použijte i tu bez něj, záleží na vás):

{KOTLIN_CONSOLE}
println("Vítejte v kalkulačce")
println("Zadejte první číslo:")
val a = readLine()!!.toDouble()
println("Zadejte druhé číslo:")
val b = readLine()!!.toDouble()
println("Zvolte si operaci:")
println("1 - sčítání")
println("2 - odčítání")
println("3 - násobení")
println("4 - dělení")
val volba = readLine()!!.toInt()
var vysledek: Double = 0.0
when (volba) {
    1 -> vysledek = a + b
    2 -> vysledek = a - b
    3 -> vysledek = a * b
    4 -> vysledek = a / b
}
if ((volba > 0) && (volba < 5)) {
    println("Výsledek: $vysledek")
} else {
    println("Neplatná volba")
}
println("Děkuji za použití kalkulačky.")
{/KOTLIN_CONSOLE}

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:

println("Vítejte v kalkulačce")
var pokracovat = "ano"
while (pokracovat == "ano") {
    println("Zadejte první číslo:")
    val a = readLine()!!.toDouble()
    println("Zadejte druhé číslo:")
    val b = readLine()!!.toDouble()
    println("Zvolte si operaci:")
    println("1 - sčítání")
    println("2 - odčítání")
    println("3 - násobení")
    println("4 - dělení")
    val volba = readLine()!!.toInt()
    var vysledek: Double = 0.0
    when (volba) {
        1 -> vysledek = a + b
        2 -> vysledek = a - b
        3 -> vysledek = a * b
        4 -> vysledek = a / b
    }
    if ((volba > 0) && (volba < 5)) {
        println("Výsledek: $vysledek")
    } else {
        println("Neplatná volba")
    }
    println("Přejete si zadat další příklad? [ano/ne]")
    pokracovat = readLine()!!
}
println("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
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á.

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 Kotlin, 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š.