Lekce 6 - Cykly ve VB.NET
V předešlém cvičení, Řešené úlohy k 5. lekci VB.NET, jsme si procvičili nabyté zkušenosti z předchozích lekcí.
Po dnešním Visual Basic .NET 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ěji0
, protože v programování vše začíná od nuly, nikoli od jedničky). Např. tedyi 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 slovemDim
. 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ínkapromenna <= koncovaHodnota
. HodnotakoncovaHodnota
je typicky celočíselná hodnota.- [krok] Příkaz
Step
je dobrovolný, pokud ho neuvedeme, bude platitpromenna = promenna + 1
. Pokud přidáme klíčové slovoStep
, můžeme detailně určit co se má s proměnnou dělat, např.Step -1
způsobí, že cyklus proměnnou snižuje o1
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:
{VBNET_CONSOLE}
Console.WriteLine("Knock")
Console.WriteLine("Knock")
Console.WriteLine("Knock")
Console.WriteLine("Penny!")
Console.ReadKey()
{/VBNET_CONSOLE}
My ale už nic nemusíme otrocky opisovat:
{VBNET_CONSOLE}
For i As Integer = 0 To 2
Console.WriteLine("Knock")
Next
Console.WriteLine("Penny!")
Console.ReadKey()
{/VBNET_CONSOLE}
Konzolová aplikace
Knock
Knock
Knock
Penny!
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()
.
{VBNET_CONSOLE}
For i As Integer = 1 To 10
Console.Write("{0} ", i)
Next
Console.ReadKey()
{/VBNET_CONSOLE}
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:
{VBNET_CONSOLE}
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()
{/VBNET_CONSOLE}
Konzolová aplikace
Malá násobilka pomocí cyklů:
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:
{VBNET_CONSOLE}
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()
{/VBNET_CONSOLE}
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.WriteLine()
. 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:
{VBNET_CONSOLE}
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 = 1 To n - 1
vysledek = vysledek * a
Next
Console.WriteLine("Výsledek: {0}", vysledek)
Console.WriteLine("Děkuji za použití mocninátoru")
Console.ReadKey()
{/VBNET_CONSOLE}
Asi všichni tušíme, jak funguje mocnina. Pro jistotu připomenu, že
například 2^3 = 2 * 2 * 2
. Tedy a^n
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á.
Konzolová aplikace
Mocninátor
==========
Zadejte základ mocniny:
2
Zadejte exponent:
3
Výsledek: 8
Děkuji za použití mocninátoru
Poznámka: Pro účel mocnin slouží ve VB.NET operátor
^
(napíšete Alt + 94). Místo cyklu by tedy
šlo napsat:
{VBNET_CONSOLE}
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()
{/VBNET_CONSOLE}
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:
{VBNET_CONSOLE}
' tento kód je špatně
For i As Integer = 1 To 10
i = 1
Next
Console.ReadKey()
{/VBNET_CONSOLE}
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
:
{VBNET_CONSOLE}
Dim i As Integer = 1
While i <= 10
Console.Write("{0} ", i)
i += 1
End While
Console.ReadKey()
{/VBNET_CONSOLE}
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 Case
, ale klidně
použijte i tu bez něj, záleží na vás):
{VBNET_CONSOLE}
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()
{/VBNET_CONSOLE}
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()
Konzolová aplikace
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á. Již toho umíme docela dost, začíná to být zábava, že?
V následujícím cvičení, Řešené úlohy k 6. lekci VB.NET, si procvičíme nabyté zkušenosti z předchozích lekcí.