6. diel - Cykly vo Visual Basicu

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

V minulej lekcii, Riešené úlohy k 5. lekcii VB.NET , sme si vysvetlili podmienky. Teraz prejdeme k cyklom. Po dnešnom Visual Basic .NET tutoriálu už budeme mať takmer kompletnú výbavu základných konštrukcií a budeme schopní tvoriť rozumné aplikácie.

Cykly

Ako už slovo cyklus napovie, niečo sa bude opakovať. Keď chceme v programe niečo urobiť 100x, určite nebudeme písať pod seba 100x ten istý kód, ale vložíme ho do cyklu. Cyklov máme niekoľko druhov, vysvetlíme si, kedy ktorý použiť. Samozrejme si ukážeme praktické príklady.

For cyklus

Tento cyklus má stanovený pevný počet opakovaní a hlavne obsahuje tzv. Riadiace premennú (typicky celočíselnú), v ktorej sa postupne počas behu cyklu menia hodnoty. Syntax (zápis) cyklu for je nasledovná:

For premenna As Integer = pocatecniHodnota To koncovaHondnota [Step 1]
' Nejaké príkazy...
Next

• promenna je riadiaca premenná cyklu, ktoré nastavíme počiatočnú hodnotu (najčastejšie 0, pretože v programovaní všetko začína od nuly, nie od jednotky). Napr. teda i As Integer = 0. Samozrejme si môžeme premennú aj vytvoriť niekde nad tým a už nemusíme deklarovať premennú v cykle. Tu platí jedna z mála výnimiek, že sa premenná nemusí deklarovať kľúčovým slovom Dim. Býva zvykom používať práve i.
• konocovaHodnota značí koľkokrát sa cyklus vykoná (presnejšie do koľkých má cyklus napočítať). V skutočnosti je to podmienka `promenna
• [krok] Príkaz Step je dobrovoľný, ak ho neuvedieme, bude platiť promenna = promenna + 1. Ak pridáme kľúčové slovo Step, môžeme detailne určiť čo sa má s premennou robiť, napr. Step -1 spôsobí, že cyklus premennú znižuje o 1 miesto aby ju zvyšoval. Samozrejme potom musí byť konečná hodnota nižšia ako tá počiatočná, aby cyklus niekedy skončil. Hranaté zátvorky označujú dobrovoľnosť tejto konštrukcie a do kódu sa nepíšu.

Poďme si urobiť jednoduchý príklad, väčšina z nás určite pozná Sheldona z The Big Bang Theory. Pre tých čo nie, budeme simulovať situáciu, kedy klope na dvere svojej susedky. Vždy 3x zaklope a potom zavolá: "Penny!". Náš kód by bez cyklov vyzeral takto:

{VBNET_CONSOLE}
Console.WriteLine("Knock")
Console.WriteLine("Knock")
Console.WriteLine("Knock")
Console.WriteLine("Penny!")
Console.ReadKey()
{/VBNET_CONSOLE}

My ale už nič nemusíme otrocky opisovať:

{VBNET_CONSOLE}
For i As Integer = 0 To 2
    Console.WriteLine("Knock")
Next
Console.WriteLine("Penny!")
Console.ReadKey()
{/VBNET_CONSOLE}

Konzolová aplikácia
Knock
Knock
Knock
Penny!

Cyklus prebehne 3x, spočiatku je v premennej i nula, cyklus vypíše "Knock" a zvýši premennú i o jedna. Potom beží rovnako s jednotkou a dvojkou. Teraz môžeme namiesto dvojky napísať do deklarácie cyklu desiatku (deviatku, pretože začíname na nule). Príkaz sa vypíše 10x bez toho aby sme písali niečo navyše. Určite vidíte, že cykly sú mocným nástrojom.

Skúsme si teraz využiť to, že sa nám premenná inkrementuje. Vypíšme si čísla od jednej do desať. Pretože nebudeme chcieť, aby sa nám v konzole text vždy odřádkoval, použijeme miesto WriteLine() iba Write().

{VBNET_CONSOLE}
For i As Integer = 1 To 10
    Console.Write("{0} ", i)
Next
Console.ReadKey()
{/VBNET_CONSOLE}

Vidíme, že riadiaci premenná má naozaj v každej iterácii (priebehu) inú hodnotu. Všimnite si, že v cykle tentoraz nezačíname na nule, ale môžeme nastaviť počiatočnú hodnotu 1 a koncovú 10. V programovaní je však zvykom začínať od nuly, neskôr zistíme prečo.

Teraz si vypíšeme malú násobilku (násobky čísel 1 až 10, vždy do desať). Stačí nám urobiť cyklus od 1 do 10 a premennú vždy násobiť daným číslom. Mohlo by to vyzerať asi takto:

{VBNET_CONSOLE}
Console.WriteLine("Malá násobilka pomocou cyklov:")
For i As Integer = 1 To 10
    Console.Write("{0} ", i)
Next
Console.WriteLine()
For i As Integer = 1 To 10
    Console.Write("{0} ", i * 2)
Next
Console.WriteLine()
For i As Integer = 1 To 10
    Console.Write("{0} ", i * 3)
Next
Console.WriteLine()
For i As Integer = 1 To 10
    Console.Write("{0} ", i * 4)
Next
Console.WriteLine()
For i As Integer = 1 To 10
    Console.Write("{0} ", i * 5)
Next
Console.WriteLine()
For i As Integer = 1 To 10
    Console.Write("{0} ", i * 6)
Next
Console.WriteLine()
For i As Integer = 1 To 10
    Console.Write("{0} ", i * 7)
Next
Console.WriteLine()
For i As Integer = 1 To 10
    Console.Write("{0} ", i * 8)
Next
Console.WriteLine()
For i As Integer = 1 To 10
    Console.Write("{0} ", i * 9)
Next
Console.WriteLine()
For i As Integer = 1 To 10
    Console.Write("{0} ", i * 10)
Next
Console.WriteLine()
Console.ReadKey()
{/VBNET_CONSOLE}

Konzolová aplikácia
Malá násobilka pomocou cyklov:
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 pekne, ale stále sme toho dosť napísali. Ak vás napadlo, že v podstate robíme 10x to isté a len zvyšujeme číslo, ktorým násobíme, máte pravdu. Nič nám nebráni vložiť 2 cykly do seba:

{VBNET_CONSOLE}
Console.WriteLine("Malá násobilka pomocou dvoch cyklov:")
For j As Integer = 1 To 10
    Console.WriteLine()
    For i As Integer = 1 To 10
        Console.Write("{0} ", i * j)
    Next
Next
Console.ReadKey()
{/VBNET_CONSOLE}

Pomerne zásadný rozdiel, že? Pochopiteľne nemôžeme použiť u oboch cyklov i, pretože sú vložené do seba. Premenná j nadobúda vo vonkajšom cykle hodnoty 1 až 10. V každej iterácii (rozumejte priebehu) cyklu je potom spustený ďalší cyklus s premennou i. Ten je nám už známy, vypíše násobky, v tomto prípade násobíme premennú j. Po každom behu vnútorného cyklu treba odřádkovat, to vykoná Console.WriteLine(). Môžete si skúsiť vypísané riadky upravená pomocou metódy PadLeft() tak, aby boli čísla pekne v stĺpcoch.

Urobme si ešte jeden program, na ktorom si ukážeme prácu s vonkajšou premennou. Aplikácia bude vedieť spočítať ľubovoľnú mocninu ľubovoľného čísla:

{VBNET_CONSOLE}
Console.WriteLine("Mocninátor")
Console.WriteLine("==========")
Console.WriteLine("Zadajte základ mocniny: ")
Dim a As Integer = Console.ReadLine()
Console.WriteLine("Zadajte exponent: ")
Dim n As Integer = Console.ReadLine()

Dim vysledek = a
For i As Integer = 1 To n - 1
    vysledek = vysledek * a
Next
Console.WriteLine("Výsledok: {0}", vysledek)
Console.WriteLine("Ďakujem za použitia mocninátoru")
Console.ReadKey()
{/VBNET_CONSOLE}

Asi všetci tušíme, ako funguje mocnina. Pre istotu pripomeniem, že napríklad 2^3 = 2 * 2 * 2. Teda a^n spočítame tak, že n-1 krát vynásobíme číslo a číslom a. Výsledok si samozrejme musíme ukladať do premennej. Spočiatku bude mať hodnotu a a postupne sa bude v cykle pronásobovat. Ak ste to nestihli, máme tu samozrejme článok s algoritmom výpočtu ľubovoľnej mocniny. Vidíme, že naša premenná vysledek je v tele cyklu normálne prístupná. Ak si však nejakú premennú založíme v tele cyklu, po skončení cyklu zanikne a už nebude prístupná.

Konzolová aplikácia
Mocninátor
==========
Zadajte základ mocniny:
2
Zadajte exponent:
3
Výsledok: 8
Ďakujem za použitia mocninátoru

Poznámka: Pre účel mocnín slúži vo VB.NET operátor ^ (napíšete Alt + 94). Namiesto cyklu by teda išlo napísať:

{VBNET_CONSOLE}
Console.WriteLine("Mocninátor")
Console.WriteLine("==========")
Console.WriteLine("Zadajte základ mocniny: ")
Dim a As Integer = Console.ReadLine()
Console.WriteLine("Zadajte exponent: ")
Dim n As Integer = Console.ReadLine()
Dim vysledek = a ^ n
Console.WriteLine("Výsledok: {0}", vysledek)
Console.WriteLine("Ďakujem za použitia mocninátoru")
Console.ReadKey()
{/VBNET_CONSOLE}

Už tušíme, na čo sa For cyklus využíva. Zapamätajme si, že väčšinou je počet opakovaní pevne daný. Do premennej cyklu by sme nemali nijako zasahovať ani dosadzovať, program by sa mohol tzv. Zacykliť, skúsme si ešte posledný, odstrašujúci príklad:

{VBNET_CONSOLE}
' tento kód je zle
For i As Integer = 1 To 10
    i = 1
Next
Console.ReadKey()
{/VBNET_CONSOLE}

Au, vidíme, že program sa zasekol. Cyklus stále inkrementuje premennú i, ale tá sa vždy zníži na 1. Nikdy teda nedosiahne hodnoty > 10, cyklus nikdy neskončí. Okno programu zatvoríme alebo použijeme tlačidlo Stop v lište Visual Studia.

While cyklus

While cyklus funguje inak, jednoducho opakuje príkazy v bloku kým platí podmienka. Syntax cyklu je nasledovné:

While podmienka
' Kód
End While

Ak vás napadá, že možno cez While cyklus urobiť aj For cyklus, máte pravdu For je vlastne špeciálny prípad While cyklu. While sa ale používa na trochu iné veci, často máme v jeho podmienke napr. Metódu vracajúci logickú hodnotu True / False. Pôvodný príklad z For cyklu by sme urobili nasledovne pomocou While:

{VBNET_CONSOLE}
Dim i As Integer = 1
While i <= 10
    Console.Write("{0} ", i)
    i += 1
End While
Console.ReadKey()
{/VBNET_CONSOLE}

To ale nie je ideálne použitie While cyklu. Vezmeme si našu kalkulačku z minulých lekcií a opäť ju trochu vylepšíme, konkrétne o možnosť zadať viac príkladov. Program teda hneď neskončí, ale spýta sa užívateľa, či si praje spočítať ďalší príklad. Pripomeňme si pôvodnú verziu kódu (je to tá verzia so Select Case, ale pokojne použite aj tú bez neho, záleží na vás):

{VBNET_CONSOLE}
Console.WriteLine("Vitajte v kalkulačke")
Console.WriteLine("Zadajte prvé číslo:")
Dim a As Single = Console.ReadLine()
Console.WriteLine("Zadajte druhé číslo:")
Dim b As Single = Console.ReadLine()
Console.WriteLine("Zvoľte si operáciu:")
Console.WriteLine("1 - sčítanie")
Console.WriteLine("2 - odčítanie")
Console.WriteLine("3 - násobenie")
Console.WriteLine("4 - delenie")
Dim volba As Integer = Console.ReadLine()
Dim vysledek As Single = 0
Select Case volba
    Case 1
        vysledek = a + b
    Case 2
        vysledek = a - b
    Case 3
        vysledek = a * b
    Case 4
        vysledek = a / b
End Select
If volba > 0 And volba < 5 Then
    Console.WriteLine("Výsledok: {0}", vysledek)
Else
    Console.WriteLine("Neplatná voľba")
End If
Console.WriteLine("Ďakujem za použitia kalkulačky, aplikáciu ukončíte ľubovoľnou klávesou.")
Console.ReadKey()
{/VBNET_CONSOLE}

Teraz vložíme takmer celý kód do While cyklu. Našou podmienkou bude, že používateľ zadá "Ano", budeme teda kontrolovať obsah premennej pokracovat. Spočiatku bude táto premenná nastavená na "Ano", aby sa program vôbec spustil, potom do nej necháme načítať voľbu užívateľa:

Console.WriteLine("Vitajte v kalkulačke")
Dim pokracovat As String = "Áno"
While pokracovat = "Áno"
    Console.WriteLine("Zadajte prvé číslo:")
    Dim a As Single = Console.ReadLine()
    Console.WriteLine("Zadajte druhé číslo:")
    Dim b As Single = Console.ReadLine()
    Console.WriteLine("Zvoľte si operáciu:")
    Console.WriteLine("1 - sčítanie")
    Console.WriteLine("2 - odčítanie")
    Console.WriteLine("3 - násobenie")
    Console.WriteLine("4 - delenie")
    Dim volba As Integer = Console.ReadLine()
    Dim vysledek As Single = 0
    Select Case volba
        Case 1
            vysledek = a + b
        Case 2
            vysledek = a - b
        Case 3
            vysledek = a * b
        Case 4
            vysledek = a / b
    End Select
    If volba > 0 And volba < 5 Then
        Console.WriteLine("Výsledok: {0}", vysledek)
    Else
        Console.WriteLine("Neplatná voľba")
    End If
    Console.WriteLine("Prajete si zadať ďalší príklad? [áno/nie]")
    pokracovat = Console.ReadLine()
End While
Console.WriteLine("Ďakujem za použitia kalkulačky, aplikáciu ukončíte ľubovoľnou klávesou.")
Console.ReadKey()

Konzolová aplikácia
Vitajte v kalkulačke
Zadajte prvé číslo:
12
Zadajte druhé číslo:
128
Zvoľte si operáciu:
1 - sčítanie
2 - odčítanie
3 - násobenie
4 - delenie
1
Výsledok: 140
Prajete si zadať ďalší príklad? [áno/nie]
áno
Zadajte prvé číslo:
-10,5
Zadajte druhé číslo:

Naši aplikáciu možno teraz používať viackrát a je už takmer hotová. V budúcej lekcii, Riešené úlohy k 6. lekcii VB.NET , si ukážeme, ako zabezpečiť všetky vstupy od užívateľa.

Už toho vieme celkom dosť, začína to byť zábava, že?

V nasledujúcom cvičení, Riešené úlohy k 6. lekcii VB.NET, si precvičíme nadobudnuté skúsenosti z predchádzajúcich lekcií.