6. díl - Cykly ve Visual Basicu

Ostatní jazyky Visual Basic .NET Základní konstrukce Cykly ve Visual Basicu

Minule jsme si v tutoriálu vysvětlili podmínky. Nyní přejdeme k cyklům, po dnešním 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

Tento cyklus má stanovený pevný počet opakování a hlavně obsahuje tzv. řídící proměnnou (typicky celočíselnou), ve které se postupně během běhu cyklu mění hodnoty. Syntaxe (zápis) cyklu for je následující:

For promenna As Integer = pocatecniHodnota To koncovaHondnota [Step 1]
'Nějaké příkazy...
Next
  • promenna je řídící proměnná cyklu, které nastavíme počáteční hodnotu (nejčastěji 0, protože v programování vše začíná od nuly, nikoli od jedničky). Např. tedy i As Integer = 0. Samozřejmě si můžeme proměnnou i vytvořit někde nad tím a už nemusíme deklarovat proměnnou v cyklu. Zde platí jedna z mála výjimek, že se proměnná nemusí deklarovat klíčovým slovem Dim. Bývá zvykem používat právě i.
  • konocovaHodnota značí kolikrát se cyklus provede (přesněji do kolika má cyklus napočítat). Ve skutečnosti je to podmínka promenna <= koncovaHodnota. KoncovaHodnota je typicky celočíselná hodnota.
  • [krok] Příkaz Step je dobrovolný, pokud ho neuvedeme, bude platit promenna = promenna + 1. Pokud přidáme klíčové slovo Step, můžeme detailně určit co se má s proměnnou dělat, např. Step -1 způsobí, že cyklus proměnnou snižuje o 1 místo aby ji zvyšoval. Samozřejmě poté musí být konečná hodnota nižší než ta počáteční, aby cyklus někdy skončil. Hranaté závorky označují dobrovolnost této konstrukce a do kódu se nepíší.

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:

Console.WriteLine("Knock")
Console.WriteLine("Knock")
Console.WriteLine("Knock")
Console.WriteLine("Penny!")
Console.ReadKey()

My ale už nic nemusíme otrocky opisovat:

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

Cyklus proběhne 3x, zpočátku je v proměnné i nula, cyklus vypíše "Knock" a zvýší proměnnou i o jedna. Poté běží stejně s jedničkou a dvojkou. Nyní můžeme místo dvojky napsat do deklarace cyklu desítku (devítku, jelikož začínáme na nule). Příkaz se vypíše 10x aniž bychom psali něco navíc. Určitě vidíte, že cykly jsou mocným nástrojem.

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 místo WriteLine pouze Write.

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

Vidíme, že řídící proměnná má opravdu v každé iteraci (průběhu) jinou hodnotu. Všimněte si, že v cyklu tentokrát nezačínáme na nule, ale můžeme nastavit počáteční hodnotu 1 a koncovou 10. V programování je ovšem zvykem začínat od nuly, později zjistíme proč.

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:

Console.WriteLine("Malá násobilka pomocí cyklů:")
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()

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:

Console.WriteLine("Malá násobilka pomocí dvou cyklů:")
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()

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 hodnoty 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, to vykoná Console.Write­Line(). Můžete si zkusit vypsané řádky upravit pomocí metody PadLeft tak, aby byla čísla hezky ve sloupcích.

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

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

Dim vysledek = a
For i As Integer = 0 To n
        vysledek = vysledek * a
Next
Console.WriteLine("Výsledek: {0}", vysledek)
Console.WriteLine("Děkuji za použití mocninátoru")
Console.ReadKey()

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á.

Poznámka: Pro účel mocnin slouží ve VB.NET operátor ^ (napíšete Alt + 94). Místo ckylu by tedy šlo napsat:

Console.WriteLine("Mocninátor")
Console.WriteLine("==========")
Console.WriteLine("Zadejte základ mocniny: ")
Dim a As Integer = Console.ReadLine()
Console.WriteLine("Zadejte exponent: ")
Dim n As Integer = Console.ReadLine()
Dim vysledek = a ^ n
Console.WriteLine("Výsledek: {0}", vysledek)
Console.WriteLine("Děkuji za použití mocninátoru")
Console.ReadKey()

Už tušíme, k čemu se for cyklus využívá. Zapamatujme si, že většinou je počet opakování pevně daný. Do proměnné cyklu bychom neměli nijak zasahovat ani dosazovat, program by se mohl tzv. zacyklit, zkusme si ještě poslední, odstrašující příklad:

' tento kód je špatně
For i As Integer = 1 To 10
        i = 1
Next
Console.ReadKey()

Au, vidíme, že program se zasekl. Cyklus stále inkrementuje proměnnou i, ale ta se vždy sníží na 1. Nikdy tedy nedosáhne hodnoty > 10, cyklus nikdy neskončí. Okno programu zavřeme nebo použijeme tlačítko Stop v lište Visual Studia.

While cyklus

While cyklus funguje jinak, jednoduše opakuje příkazy v bloku dokud platí podmínka. Syntaxe cyklu je následující:

While podminka
'Kód
End While

Pokud vás napadá, že lze přes While cyklus udělat i For cyklus, máte pravdu :) For je vlastně speciální případ While cyklu. 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 následovně pomocí While:

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

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

Console.WriteLine("Vítejte v kalkulačce")
Console.WriteLine("Zadejte první číslo:")
Dim a As Single = Console.ReadLine()
Console.WriteLine("Zadejte druhé číslo:")
Dim b As Single = Console.ReadLine()
Console.WriteLine("Zvolte si operaci:")
Console.WriteLine("1 - sčítání")
Console.WriteLine("2 - odčítání")
Console.WriteLine("3 - násobení")
Console.WriteLine("4 - dělení")
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ýsledek: {0}", vysledek)
Else
        Console.WriteLine("Neplatná volba")
End If
Console.WriteLine("Děkuji za použití kalkulačky, aplikaci ukončíte libovolnou klávesou.")
Console.ReadKey()

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:

Console.WriteLine("Vítejte v kalkulačce")
Dim pokracovat As String = "Ano"
While pokracovat = "Ano"
        Console.WriteLine("Zadejte první číslo:")
        Dim a As Single = Console.ReadLine()
        Console.WriteLine("Zadejte druhé číslo:")
        Dim b As Single = Console.ReadLine()
        Console.WriteLine("Zvolte si operaci:")
        Console.WriteLine("1 - sčítání")
        Console.WriteLine("2 - odčítání")
        Console.WriteLine("3 - násobení")
        Console.WriteLine("4 - dělení")
        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ýsledek: {0}", vysledek)
        Else
                Console.WriteLine("Neplatná volba")
        End If
        Console.WriteLine("Přejete si zadat další příklad? [ano/ne]")
        pokracovat = Console.ReadLine()
End While
Console.WriteLine("Děkuji za použití kalkulačky, aplikaci ukončíte libovolnou klávesou.")
Console.ReadKey()

Naši aplikaci lze nyní používat vícekrát a je již téměř hotová. Příště 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? :)


 

  Aktivity (2)

Článek pro vás napsal Michal Žůrek (misaz)
Avatar
Autor se věnuje tvorbě aplikací pro počítače, mobilní telefony, mikroprocesory a tvorbě webových stránek a webových aplikací. Nejraději programuje ve Visual Basicu a TypeScript. Ovládá HTML, CSS, JavaScript, TypeScript, C# a Visual Basic.

Jak se ti líbí článek?
Celkem (5 hlasů) :
4.84.84.84.84.8


 


Miniatura
Předchozí článek
Cvičení k 5. lekci VB.NET
Miniatura
Následující článek
Cvičení k 6. lekci VB.NET

 

 

Komentáře

Avatar
Kit
Redaktor
Avatar
Kit:

Je škoda, že modifikaci řídící proměnné uvnitř cyklu neohlásí překladač jako chybu.

Odpovědět 29.4.2013 14:30
Vlastnosti objektů by neměly být veřejné. A to ani prostřednictvím getterů/setterů.
Avatar
Odpovídá na Kit
Michal Žůrek (misaz):

Ono to totiž chyba není, občas se toho může využít. Pouze to však nedoporučuje.

Odpovědět 29.4.2013 19:34
Nesnáším {}, proto se jim vyhýbám.
Avatar
Kit
Redaktor
Avatar
Odpovídá na Michal Žůrek (misaz)
Kit:

Sice mě napadlo, jak by se toho dalo využít, ale takové hnusné hacky se do programů dávat nemají. Je lepší, když se programátor drží vlastního pravidla, že modifikování řídící proměnné cyklu mimo jeho hlavičku je zakázáno.

Odpovědět 30.4.2013 10:25
Vlastnosti objektů by neměly být veřejné. A to ani prostřednictvím getterů/setterů.
Avatar
Odpovídá na Kit
Michal Žůrek (misaz):

Využít se toho dá, ale většinou to lze řešit i jinak.

Odpovědět 30.4.2013 11:05
Nesnáším {}, proto se jim vyhýbám.
Avatar
Ondrej_d
Člen
Avatar
Ondrej_d:

Zdravim, objavil som tento fantasticky tutorial na VB a chcem autorovi podakovat za skvelu pracu! Pustil som sa do toho a za jeden den som sa bol schopny naucit zaklady VB co je uplne uzasne!

tiez by som sa chcel opytat ze preco nefunguje mocninator?
Ak som chcel aby pocital spravne, musel som odpocitat od n 2:

Console.Write­Line("Mocniná­tor")
Console.Write­Line("========­==")
Console.Write­Line("Zadejte základ mocniny: ")
Dim a As Integer = Console.ReadLine()
Console.Write­Line("Zadejte exponent: ")
Dim n As Integer = Console.ReadLine()

Dim vysledek = a
For i = 0 To (n - 2)
vysledek = vysledek * a
Next
Console.Write­Line("Výsledek: {0}", vysledek)
Console.Write­Line("Děkuji za použití mocninátoru")
Console.ReadKey()

len takto som dostaval spravny vysledok.

 
Odpovědět 13.2.2015 17:25
Avatar
Odpovídá na Ondrej_d
Michal Žůrek (misaz):

jo máš pravdu, protože zcela podle záměru by to mělo být

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

Dim vysledek = 1
For i = 1 To n
        vysledek = vysledek * a
Next
Console.WriteLine("Výsledek: {0}", vysledek)
Console.WriteLine("Děkuji za použití mocninátoru")
Console.ReadKey()

ale i tvoje řešení je správné.

Odpovědět 13.2.2015 18:45
Nesnáším {}, proto se jim vyhýbám.
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.

Zobrazeno 6 zpráv z 6.