Lekce 5 - Cykly v Kotlinu

V předešlém cvičení, Řešené úlohy ke 4. lekci Kotlinu, 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ídá, něco se bude opakovat. Když chceme v programu něco udělat stokrát, jistě nebudeme stokrát psát pod sebe tentýž kód. Místo toho jej vložíme do cyklu. Cyklů máme více druhů. Samozřejmě si vysvětlíme, kdy který použít, a ukážeme si 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 něco udělat vícekrát. Pokud chceme např. pětkrát provést kód v cyklu, vygenerujeme si rozsah čísel od 1 do 5 a ty cyklem projedeme. Kód by byl následující:

for (i in 1..5) {

}

Tímto se kód cyklu provede pětkrát 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 Kotlinu 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, kteří ho neznají, budeme simulovat situaci, kdy Sheldon klepe na dveře své sousedky. Vždy třikrát 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 už ale nic otrocky opisovat nemusíme:

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

Výsledek:

Knock
Knock
Knock
Penny!

Zkusme 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 řídicí 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 např. 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 stále jsme toho museli dost napsat. Pokud vás napadlo, že v podstatě děláme desetkrát totéž a pouze zvyšujeme číslo, kterým násobíme, máte pravdu. Nic nám nebrání v tom, abychom vložili dva 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, což vykoná println().

Vytvořme 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řipomeňme, že například 2^3 = 2 * 2 * 2. Tedy a^n spočítáme tak, že n-1krát vynásobíme číslo a číslem a. Výsledek si samozřejmě musíme ukládat do proměnné. Ta bude mít zpočátku hodnotu a a postupně se bude v cyklu pronásobovat. Pokud k mocninám potřebujete více informací, 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 přístupná již nebude.

Mocninátor
==========
Zadejte základ mocniny:
2
Zadejte exponent:
3
Výsledek: 8
Děkuji za použití mocninátoru

Už tedy tušíme, k čemu se for cyklus využívá. Zapamatujme si, že počet opakování je pevně daný. Proměnná cyklu je v každé iteraci konstanta, takže ani ji nemůžeme 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 prostřednictvím while cyklu lze 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, neboť v jeho podmínce často máme např. metodu vracející logickou hodnotu true/false. Původní příklad z for cyklu bychom pomocí cyklu while udělali 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. Vezměme si naši kalkulačku z minulých lekcí a opět ji trochu vylepšeme, 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 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 uživatelovu volbu:

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