4. diel - Podmienky (vetvenia) v Kotlin

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

V minulej lekcii Kotlin kurzu, Riešené úlohy k 3. lekcii Kotlin , sme si podrobne prebrali dátové typy. Aby sme si niečo naprogramovali, potrebujeme nejako reagovať na rôzne situácie. Môže to byť napríklad hodnota zadaná užívateľom, podľa ktorej budeme chcieť meniť ďalšie beh programu. Hovoríme, že sa program vetví a k vetvenie používame podmienky. Tým sa budeme venovať celý dnešný Kotlin tutoriál. Vytvoríme program na výpočet odmocniny a vylepšíme našu kalkulačku.

Podmienky

V Kotlin sa podmienky píšu dosť rovnako, ako vo všetkých Clik jazykoch, pre začiatočníkov samozrejme vysvetlím. Pokročilejšie sa asi budú chvíľku nudiť

Podmienky zapisujeme pomocou kľúčového slova if, za ktorým nasleduje logický výraz. Ak je výraz pravdivý, vykoná sa nasledujúci príkaz. Ak nie, nasledujúci príkaz sa preskočí a pokračuje sa až pod ním. Vyskúšajme si to:

{KOTLIN_CONSOLE}
if (15 > 5)
    println("Pravda")
println("Program tu pokračuje ďalej")
{/KOTLIN_CONSOLE}

Výstup programu:

Pravda
Program tu pokračuje ďalej

Ak podmienka platí (čo tu áno), vykoná sa príkaz Vyhlasujúca do konzoly text Pravda. V oboch prípadoch program pokračuje ďalej. Súčasťou výrazu samozrejme môže byť aj premenná:

{KOTLIN_CONSOLE}
println("Zadaj nejaké číslo")
val a = readLine()!!.toInt()
if (a > 5)
    println("Zadal si číslo väčšie ako 5!")
println("Ďakujem za zadania")
{/KOTLIN_CONSOLE}

Operátormi

Ukážme si teraz relačné operátory, ktoré môžeme vo výrazoch používať:

operátor	C-like Zápis
rovnosť	==
Je ostro väčšia	>
Je ostro menšia	<
Je väčšie alebo rovné	> =
Je menšie alebo rovné	<=
nerovnosť	! =
Všeobecná negácia	!

Rovnosť zapisujeme dvoma == preto, aby sa to neplietlo s bežným priradením do premennej, ktoré sa robí len jedným =. Ak chceme nejaký výraz znegovat, napíšeme ho do zátvorky a pred neho výkričník. V podmienkovom bloku samozrejme môžeme vykonať ľubovoľne príkazov. Ak vykonávame viac ako jeden, vkladáme ich do bloku zo zložených zátvoriek:

import kotlin.math.* // Import vždy patrí do hlavičky súboru

fun main(args: Array<String>) {
    println("Zadaj nejaké číslo, z ktorého spočítám odmocninu:")
    val a = readLine()!!.toInt()
    if (a > 0) {
        println("Zadal si číslo väčšie ako 0, to znamená, že ho môžem odmocniť!")
        val o = sqrt(a.toDouble())
        println("Odmocnina z čísla $a je $o")
    }
    println("Ďakujem za zadania")
}

výsledok:

Zadaj nejaké číslo, z ktorého spočítám odmocninu:
144
Zadal si číslo väčšie ako 0, to znamená, že ho môžem odmocniť!
Odmocnina z čísla 144 je 12.0
Ďakujem za zadania

Program načíta od užívateľa číslo a ak je väčšia ako 0, vypočíta z neho druhú odmocninu. Funkcia sqrt() vracia druhú odmocninu ako Double, ale musíme najskôr vstup konvertovať na Double. Aby sme mohli takého matematické funkcie v Kotlin používať, je potrebné najprv naimportovať kotlin.math, pozri prvý riadok zdrojového kódu vyššie. Bolo by pekné, keby nám program vyhubovala v prípade, že zadáme záporné číslo. S doterajšími znalosťami by sme napísali niečo ako:

import kotlin.math.* // Import vždy patrí do hlavičky súboru

fun main(args: Array<String>) {

    println("Zadaj nejaké číslo, z ktorého spočítám odmocninu:")
    val a = readLine()!!.toInt()
    if (a > 0) {
        println("Zadal si číslo väčšie ako 0, to znamená, že ho môžem odmocniť!")
        val o = sqrt(a.toDouble())
        println("Odmocnina z čísla $a je $o)")
    }
    if (a <= 0) {
        println("Odmocnina zo záporného čísla neexistuje!")
    }

    println("Ďakujem za zadania")
}

Všimnite si, že musíme pokryť aj prípad, kedy sa a == 0, nielen keď je menšia. Kód však môžeme výrazne zjednodušiť pomocou kľúčového slova else, ktoré vykoná nasledujúci príkaz alebo blok príkazov v prípade, že sa podmienka nevykoná:

import kotlin.math.* // Import vždy patrí do hlavičky súboru

fun main(args: Array<String>) {
    println("Zadaj nejaké číslo, z ktorého spočítám odmocninu:")
    val a = readLine()!!.toInt()
    if (a > 0) {
        println("Zadal si číslo väčšie ako 0, to znamená, že ho môžem odmocniť!")
        val o = sqrt(a.toDouble())
        println("Odmocnina z čísla $a je $o")
    }
    else
        println("Odmocnina zo záporného čísla neexistuje!")

    println("Ďakujem za zadania")
}

Kód je oveľa prehľadnejšie a nemusíme vymýšľať opačnú podmienku, čo by v prípade zloženej podmienky mohlo byť niekedy aj veľmi ťažké. V prípade viac príkazov by bol za else opäť blok { }.

Kľúčové slovo else sa tiež využíva v prípade, keď potrebujeme v príkaze manipulovať s premennou z podmienky a nemôžeme sa na ňu teda pýtať potom znova. Program si sám pamätá, že sa podmienka nesplnila, a prejde do vetvy else. Ukážme si to na príklade: Majme číslo a, kde bude hodnota 0 alebo 1 a po nás sa bude chcieť, aby sme hodnotu prehodili (ak tam je 0, dosadíme tam 1, ak 1, dosadíme 0). Naivne by sme mohli kód napísať takto:

{KOTLIN_CONSOLE}
var a = 0 // do a si priradíme na začiatku 0

if (a == 0) { // ak je a 0, dáme do neho jedničku
    a = 1
}

if (a == 1) { // ak je a 1, dáme doňho nulu
    a = 0
}
println(a)
{/KOTLIN_CONSOLE}

Nefunguje to, že? Poďme si prejsť, čo bude program robiť. Na začiatku máme v a nulu, prvá podmienka sa určite splní a dosadí do a jedničku. No ale razom sa splní aj tá druhá. Čo s tým? Keď podmienky otočíme, budeme mať ten istý problém s jednotkou. Ako z toho von? Áno, použijeme else.

{KOTLIN_CONSOLE}
var a = 0 // do a si priradíme na začiatku 0

if (a == 0) { // ak je a 0, dáme do neho jedničku
    a = 1
} else { // ak je a 1, dáme doňho nulu
    a = 0
}

println(a)
{/KOTLIN_CONSOLE}

Podmienky je možné skladať a to pomocou dvoch základných logických operátorov:

operátor	C-like Zápis
A zároveň	&&
alebo	||

Uveďme si príklad:

{KOTLIN_CONSOLE}
println("Zadajte číslo v rozmedzí 10-20:")
val a = readLine()!!.toInt()
if (a >= 10 && a <= 20) {
    println("Zadal si správne")
} else {
    println("Zadal si zle")
}
{/KOTLIN_CONSOLE}

S tým si zatiaľ vystačíme, operátorov sa pomocou zátvoriek samozrejme dajú kombinovať.

{KOTLIN_CONSOLE}
println("Zadajte číslo v rozmedzí 10-20 alebo 30-40:")
val a = readLine()!!.toInt()
if (((a >= 10) && (a <= 20)) || ((a >=30) && (a <= 40))) {
    println("Zadal si správne")
} else {
    println("Zadal si zle")
}
{/KOTLIN_CONSOLE}

when

Konštrukcia when je prevzatá z jazyka C (ako veľká časť gramatiky Kotlin), kde je známa ako konštrukcia switch. Umožňuje nám zjednodušiť (relatívne) zápis viac podmienok pod sebou. Spomeňme si na našu kalkulačku v prvých lekciách, ktorá načítala 2 čísla a vypočítala všetky 4 operácie. Teraz si ale budeme chcieť zvoliť, ktorú operáciu chceme. Bez when by sme napísali kód podobný tomuto:

{KOTLIN_CONSOLE}
println("Vitajte v kalkulačke")
println("Zadajte prvé číslo:")
val a = readLine()!!.toDouble()
println("Zadajte druhé číslo:")
val b = readLine()!!.toDouble()
println("Zvoľte si operáciu:")
println("1 - sčítanie")
println("2 - odčítanie")
println("3 - násobenie")
println("4 - delenie")
val volba = readLine()!!.toInt()
var vysledek: Double = 0.0
if (volba == 1) {
    vysledek = a + b
} else if (volba == 2) {
    vysledek = a - b
} else if (volba == 3) {
    vysledek = a * b
} else if (volba == 4) {
    vysledek = a / b
}
if ((volba > 0) && (volba < 5)) {
    println("Výsledok: $vysledek")
} else {
    println("Neplatná voľba")
}
println("Ďakujem za použitia kalkulačky.")
{/KOTLIN_CONSOLE}

výstup:

Vitajte v kalkulačke
Zadajte prvé číslo:
3,14
Zadajte druhé číslo:
2,72
Zvoľte si operáciu:
1 - sčítanie
2 - odčítanie
3 - násobenie
4 - delenie
2
Výsledok: 0,42
Ďakujem za použitia kalkulačky.

Všimnite si, že sme premennú vysledek deklarovali na začiatku, len tak do nej môžeme potom priraďovať. Keby sme ju deklarovali u každého priradenie, Kotlin by kód nezkompiloval a vyhodil chybu redeklarace premenné. Premenná môže byť deklarovaná (založená v pamäti) vždy iba raz. Bohužiaľ Kotlin nie je schopný poznať, či je do premennej vysledek naozaj priradená nejaká hodnota. Ozve sa pri výpise na konzole, kde sa mu nepáči, že môže vypisovať premennú, ktorá nemá priradenú hodnotu. Z tohto dôvodu na začiatku dosadíme do vysledek nulu.

Ďalšia vychytávka je kontrola správnosti voľby. Program by v tomto prípade fungoval rovnako aj bez tých else, ale načo sa ďalej pýtať, keď už máme výsledok.

Teraz si skúsime napísať ten istý kód pomocou when:

{KOTLIN_CONSOLE}
println("Vitajte v kalkulačke")
println("Zadajte prvé číslo:")
val a = readLine()!!.toDouble()
println("Zadajte druhé číslo:")
val b = readLine()!!.toDouble()
println("Zvoľte si operáciu:")
println("1 - sčítanie")
println("2 - odčítanie")
println("3 - násobenie")
println("4 - delenie")
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ýsledok: $vysledek")
} else {
    println("Neplatná voľba")
}
println("Ďakujem za použitia kalkulačky.")
{/KOTLIN_CONSOLE}

Vidíme, že kód je trochu prehľadnejšie. Ak by sme potrebovali v nejakej vetve when spustiť viac príkazov, budeme ich písať do bloku { }. V pôvodnom switch z jazyka C sa jednotlivé vetvy museli ukončovať príkazom break, v Kotlin toto neplatí a v prípade when vždy vykoná iba jednu z nich. Konštrukcia when môže namiesto x -> obsahovať ešte možnosť else ->, ktorá sa vykoná v prípade, že nebude platiť žiadna vetva. Je len na vás, či budete when používať, všeobecne sa oplatí len pri väčšom množstve príkazov a vždy ide nahradiť sekvencií if a else. Samozrejme je možné použiť when aj pre hodnoty String ové premennej.

V budúcej lekcii, Riešené úlohy k 4. lekcii Kotlin , sa budeme venovať cyklom.

V nasledujúcom cvičení, Riešené úlohy k 4. lekcii Kotlin, 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š.