2. diel - Premenné, typový systém a parsovanie v Kotlin

Z minulej lekcie Kotlin kurzu, Úvod do jazyka Kotlin, platformy a IntelliJ , už vieme pracovať s IntelliJ a vytvoriť si nový projekt pre spúšťanie Kotlin kódu. Dnes sa v Kotlin tutoriálu pozrieme na tzv. Typový systém, ukážeme si základné dátové typy a prácu s premennými. Tiež dôjde reč na rozdiel medzi kľúčovými slovami var a val.

Premenné

Než začneme riešiť dátové typy, poďme sa zhodnúť na tom, čo je to premenná (programátori mi teraz iste odpustí zbytočné vysvetľovanie). Určite poznáte z matematiky premennou (napr. x), do ktorej sme si mohli uložiť nejakú hodnotu, najčastejšie číslo. Premenná je v informatike úplne to isté, je to miesto v pamäti počítača, kam si môžeme uložiť nejaké dáta (meno používateľa, aktuálny čas alebo databázu článkov). Toto miesto má podľa typu premennej tiež vyhradenú určitú veľkosť, ktorú premenná nesmie presiahnuť (napr. Číslo nesmie byť väčšie ako 2 147 483 647).

Premenná má vždy nejaký dátový typ, môže to byť číslo, znak, text a podobne, záleží na tom, na čo ju chceme používať. Väčšinou musíme pred prácou s premennou túto premennú najskôr tzv. Deklarovať, či povedať jazyku ako sa bude volať a akého dátového typu bude (aký v nej bude obsah). Jazyk ju v pamäti založia a až potom s ňou môžeme pracovať. Podľa dátového typu premennej si ju jazyk dokáže z pamäti načítať, modifikovať, prípadne ju v pamäti založiť. O každom dátovom typu jazyk vie, koľko v pamäti zaberá miesta a ako s týmto kusom pamäte pracovať.

Typový systém

Existujú dva základné typové systémy: statický a dynamický:

• Dynamický typový systém nás plne odtieňuje od toho, že premenná má vôbec nejaký dátový typ. Ona ho samozrejme vnútorne má, ale jazyk to nedáva najavo. Dynamické typovanie ide mnohokrát tak ďaleko, že premenné nemusíme ani deklarovať, akonáhle do nejakej premennej niečo uložíme a jazyk zistí, že nebola nikdy deklarovaná, sám ju založí. Do tej istej premennej môžeme ukladať text, potom objekt používateľa a potom desatinné číslo. Jazyk sa s tým sám pobije a vnútorne automaticky mení dátový typ. V týchto jazykoch ide vývoj rýchlejšie vďaka menšiemu množstvo kódu, zástupcovia sú napr. PHP alebo Ruby.
• Statický typový systém naopak striktne vyžaduje definovať typ premennej a tento typ je ďalej nemenný. Akonáhle premennú raz deklarujeme, nie je možné jej dátový typ zmeniť. Akonáhle sa do textového reťazca pokúsime uložiť objekt užívateľ, dostaneme vynadané.

Kotlín je staticky typizovanom jazyk, všetky premenné teda majú pevne daný typ údajov. Ten ale často nemusíme udávať, kompilátor vhodný dátový typ sám doplní, ak ho neurčíme explicitne. Obrovskou výhodou je, že nám kompilátor pred spustením skontroluje, či všetky dátové typy sedia. Dynamické typovanie síce vyzerá ako výhodné, ale zdrojový kód nie je možné automaticky kontrolovať a keď niekde očakávame objekt používateľ a príde nám tam namiesto toho desatinné číslo, odhalí sa chyba až za behu a interpret program zhodí. Naopak Kotlin nám nedovolí program ani skompilovať a na chybu nás upozorní (to je ďalšia výhoda kompilácia).

Poďme si teraz niečo naprogramovať, nech si nadobudnuté vedomosti trochu osvojíme, s teóriou budeme pokračovať až nabudúce. Povedzme si teraz tri základné dátové typy:

• Celé čísla: Int
• Desatinné čísla: Double
• Textový reťazec: String

Práca s premennými

Skúsime si nadeklarovat celočíselnú premennú a, dosadiť do nej číslo 56 a obsah tejto premennej vypísať. Založte si nový projekt s názvom Promenne. Nezabudnite, že celý kód musíme vložiť do funkcie main(). V príklade nižšie si ju ešte uvedieme, u tých ďalších ju vždy pripíšte už sami:

Metódu main() nám môže pomôcť vygenerovať IntelliJ. Stačí napísať text main a stlačiť klávesu Enter alebo Tab.

fun main(args: Array<String>) {
    var a: Int

    a = 56

    println(a)
}

Keď program spustíme, uvidíme v konzole číslo 56:

56

Prvý príkaz nám nadeklaruje novú premennú a dátového typu Int. Premenná teda bude slúžiť na ukladanie celých čísel. Druhý príkaz vykonáva priradenie do premennej, slúži na to operátor "rovná sa" (=). Posledný príkaz už dobre poznáme, slúži k výpisu do konzoly.

Kód by sme mohli skrátiť a deklaráciu s inicializáciou premennej vykonať v jednom kroku:

{KOTLIN_CONSOLE}
var a = 56
println(a)
{/KOTLIN_CONSOLE}

Kompilátor sám spozná, že hodnote 56 najlepšie zodpovedá dátový typ Int a na pozadí ho doplní. Samozrejme by sme typ mohli aj explicitne uviesť:

var a: Int = 56

V Kotlin sa však väčšinou dátové typy takto nešpecifikujú.

Ukážme si ešte ako by náš program vyzeral s premennou pre desatinné čísla:

{KOTLIN_CONSOLE}
var a = 56.6
println(a)
{/KOTLIN_CONSOLE}

Je to takmer rovnaké ako s celočíselným. Ako desatinný oddeľovač používame bodku (.).

var vs. val

Zatiaľ sme sa u premenných zoznámili so slovkom var, ktoré práve premennú označuje. Častejšie ale vo svete Kotlin stretneme podobné slovko val. To slúži pre deklaráciu nemenné premenné, ktorú nie je ďalej možné meniť. Pretože v bežnom programovaní je takých hodnôt väčšina, používa sa primárne val a var iba v prípade, že plánujete hodnotu premennej ďalej meniť. val nám zaistí, že má premenná vždy konštantnú hodnotu, ktorú sme jej prvýkrát priradili, a nikdy sa nám nestane, že by nejaká časť kódu omylom menila hodnotu našich premenných.

Funkčnosť val si môžeme ľahko overiť napríklad takto:

val a: Int

a = 56

a = 22

Ako môžete vidieť, IntelliJ zobrazí chybu, pretože nie je možné meniť hodnotu val premennej.

Program Papagáj

Minulý program bol trochu nudný, skúsme nejako reagovať na vstup od užívateľa. Napíšeme program papagáj, ktorý bude dvakrát opakovať to, čo používateľ napísal. Ešte sme neskúšali z konzoly nič načítavať, ale je to veľmi jednoduché. Slúži na to funkcia readLine(), ktorá nám vráti textový reťazec z konzoly. Skúsme si napísať nasledujúci kód:

{KOTLIN_CONSOLE}
println("Ahoj, som virtuálne papagáj Lora, rád opakujem!")
println("Napíš niečo: ")

var vstup: String
vstup = readLine()!!

var vystup: String
vystup = vstup + ", " + vstup + "!"

println(vystup)
{/KOTLIN_CONSOLE}

To už je trochu zábavnejšia Prvé dva riadky sú jasné, ďalej deklarujeme textový reťazec vstup. Do vstup sa priradí hodnota z funkcie readLine(), teda to, čo používateľ zadal. Výkričníky za metódou zatiaľ neriešte, slúži na to, aby sme nemuseli vstup overovať. Pre výstup si pre názornosť zakladáme ďalšie premennú typu textový reťazec. Zaujímavé je, ako do vystup priradíme, tam využívame tzv. Konkatenace (spájanie) reťazcov. Pomocou operátora + totiž môžeme spojiť niekoľko textových reťazcov do jedného a je jedno, či je reťazec v premennej alebo je explicitne zadaný v úvodzovkách vo zdroj. kódu. Do premennej teda priradíme vstup, ďalej čiarku, znovu vstup a potom výkričník. Premennú vypíšeme a skončíme.

Ahoj, som virtuálne papagáj Lora, rád opakujem!
Napíš niečo:
Nazdar vtákovi
Nazdar vtákovi, Nazdar vtákovi!

Do premennej môžeme priraďovať už v jej deklarácii, môžeme teda nahradiť:

var vstup: String
vstup = readLine()!!

za:

val vstup = readLine()!!

Program by išiel skrátiť ešte viac v mnohých ohľadoch. Všeobecne je ale lepšie používať viac premenných a dodržiavať prehľadnosť, než písať čo najkratšie kód a po mesiaci zabudnúť, ako vôbec funguje.

Program zdvojnásobovač

Zdvojnásobovač si vyžiada na vstupe číslo a to potom zdvojnásobí a vypíše. Asi by sme s doterajšími znalosťami napísali niečo takéto:

println("Zadajte číslo k zdvojnásobeniu:")
var a: Int = readLine()!!
a = a * 2
println(a)

Všimnite si zdvojnásobenie čísla a, ktoré sme vykonali pomocou priradenia. Kotlín nám teraz vynadá a podčiarkne riadok, v ktorom sa snažíme hodnotu z konzoly dostať do premennej typu Int. Narážame na typovú kontrolu, konkrétne nám readLine() vracia String a my sa ho snažíme uložiť do Int. Čokoľvek príde z textovej konzoly je vždy text a to aj keď zadáme číslo. Budeme ho potrebovať tzv. Naparsovat.

Parsovanie

Parsováním sa myslí prevod z textovej podoby na nejaký špecifický typ, napr. Číslo. Často totiž od užívateľa či nejakej služby dostanete dáta ako String, ale vy pre ďalšie výpočty potrebujete napríklad Int alebo Double. Parsovanie je v Kotlin veľmi jednoduché, má ale zásadné "ale", o ktorom si krátko povieme nižšie. Ak budeme chcieť naparsovat napr. Int zo String, budeme postupovať takto:

val a = "343".toInt()

Vidíme, že dátový typ String ponúka metódu toInt() na přetypovávání na typ Int. Metóda berie ako parameter textový reťazec a vráti reťazec prevedený na celé číslo. O ďalších podobných metódach si povieme podrobnejšie ďalej v kurze. Využijeme tejto znalosti v našom programe:

{KOTLIN_CONSOLE}
println("Zadajte číslo k zdvojnásobeniu:")
val vstup = readLine()!!
var a = vstup.toInt() // prípadne Double
a = a * 2
println(a)
{/KOTLIN_CONSOLE}

Obdobne budete postupovať v prípade Double:

var parsedDouble = "34.2".toDouble()

Parsovanie sa samozrejme nemusí podariť. Predstavte si, že bude v texte namiesto čísla napr. " slovo ". Ak si skúsite parsovať čokoľvek, čo nie je číslo, tak uvidíte, že vám aplikácia spadne. IntelliJ vypíše v konzole červeným výrazným textom Exception in thread "main" java.lang.NumberFormatException: For input string: " slovo ".

Jednoduchá kalkulačka

Ešte sme nepracovali s desatinnými číslami, skúsme si napísať sľubovanú kalkulačku. Bude veľmi jednoduchá, na vstup prídu dve čísla, program potom vypíše výsledky pre sčítanie, odčítanie, násobenie a delenie.

{KOTLIN_CONSOLE}
println("Vitajte v kalkulačke")
println("Zadajte prvé číslo:")
val a = readLine()!!.toDouble()
println("Zadajte druhé číslo:")
val b = readLine()!!.toDouble()
val soucet = a + b
val rozdil = a - b
val soucin = a * b
val podil = a / b
println("Súčet: ${soucet}")
println("Rozdiel: ${rozdil}")
println("Súčin: ${soucin}")
println("Podiel: ${podil}")
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
Súčet: 5.86
Rozdiel: 0.41999999999999993
Súčin: 8.5408
Podiel: 1.1544117647058822
Ďakujem za použitia kalkulačky.

Všimnite si dvoch vecí. Po prvé sme zjednodušili parsovanie z konzoly tak, aby sme nepotrebovali stringové premennú, pretože by sme ju rovnako už potom nepoužili. Po druhé na konci programu potrebujeme vypísať čísla a pred nimi ešte sprievodný text. Aby sme mohli do text vložiť obsah našich premenných, "obalíme" naše čísla (či čokoľvek iné) do ${}. Táto praktika sa nazýva String Templating (reťazcové šablónovanie) a na pozadí skrátka dôjde k vyhodnoteniu výrazu v ${}. Pokojne by ste tu mohli číslo ešte treba vynásobiť či byť upravená.

Možno vás napadlo, že vypísať súčet 2 premenných by sa dalo aj takto jednoducho:

println("Súčet ${a + b}")

Potom máte pravdu V budúcej lekcii, Riešené úlohy k 1.-2. lekciu Kotlinu , si povieme viac o typovom systému a predstavíme si ďalšie dátové typy.

V nasledujúcom cvičení, Riešené úlohy k 1.-2. lekciu Kotlinu, 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š.