5. díl - Cykly v Kotlin

Kotlin Základy Cykly v Kotlin

ONEbit hosting Unicorn College Tento obsah je dostupný zdarma v rámci projektu IT lidem. Vydávání, hosting a aktualizace umožňují jeho sponzoři.

V minulé lekci, Podmínky (větvení) v Kotlin, jsme si vysvětlili podmínky. 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:

println("Knock")
println("Knock")
println("Knock")
println("Penny!")

My ale už nic nemusíme otrocky opisovat:

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

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

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

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:

println("Malá násobilka pomocí cyklu:")
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} ")
}

Výstup programu:

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:

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

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

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")

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 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ě:

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

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

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

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í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á. 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? :) Jelikož jsme se již několikrát setkali s tzv. nullovatelným typem (ty dva vykřičníky !!), vysvětlíme si v příští lekci, Typový systém: Null safety v Kotlin, jak funguje.


 

Stáhnout

Staženo 1x (30.62 kB)
Aplikace je včetně zdrojových kódů v jazyce Kotlin

 

 

Článek pro vás napsal Samuel Kodytek
Avatar
Jak se ti líbí článek?
Ještě nikdo nehodnotil, buď první!
Autor se věnuje Javě, Kotlinu, PHP, C, HTML. Zajímá ho spíše game design.
Miniatura
Předchozí článek
Podmínky (větvení) v Kotlin
Miniatura
Všechny články v sekci
Základní konstrukce jazyka Kotlin
Miniatura
Následující článek
Typový systém: Null safety v Kotlin
Aktivity (4)

 

 

Komentáře

Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zatím nikdo nevložil komentář - buď první!