13. diel - Cykly v C# .NET druhýkrát - do-while, break a continue

V minulej lekcii, Podmienky v C# druhýkrát-Ternárny výraz a prepadávací switch, sme sa venovali ďalšej syntaxi podmienok.

Na úvod by bolo dobré podotknúť, že dnešná lekcia obsahuje menej používané praktiky a slúži hlavne na to, aby nás tieto praktiky neprekvapili v cudzom kóde. Nie je príliš dôležité, aby sme ich sami vedeli používať.

do - while

Cyklus while už dobre poznáme. Menej používaný do - while sa líši iba tým, že sa vždy vykoná najmenej raz. Podmienka tohto cyklu je totiž umiestnená až za jeho telom. Vyzerá teda takto:

do
{
    // code...
} while (condition)

Aj na zapísanie tohto cyklu môžeme využiť snippet vo Visual Studiu: Napíšeme do a dvakrát stlačíme Tabuľátor. Zvyšok cyklu sa sám dopíše.

Príklad

Použitie do - while cyklu si ukážme na našej kalkulačke z lekcie o cykloch. Na skrátenie príkladu nebudeme používať verziu s overením užívateľských vstupov.

Variant s cyklom while

V kalkulačke sme použili cyklus while, ktorý umožnil celý program opakovať, a tak zadávať ďalšie a ďalšie príklady. Kód vyzeral takto (jedná sa o verziu s konštrukciou switch):

Console.WriteLine("Welcome to the calculator");
string continue = "Yes";
while (continue == "Yes")
{
    Console.WriteLine("Enter the first number:");
    float a = float.Parse(Console.ReadLine());
    Console.WriteLine("Enter the second number:");
    float b = float.Parse(Console.ReadLine());
    Console.WriteLine("Choose operation:");
    Console.WriteLine("1 - addition");
    Console.WriteLine("2 - subtraction");
    Console.WriteLine("3 - multiplication");
    Console.WriteLine("4 - division");
    int choice = int.Parse(Console.ReadLine());
    float result = 0;
    switch (choice)
    {
        case 1:
            result = a + b;
            break;
        case 2:
            result = a - b;
            break;
        case 3:
            result = a * b;
            break;
        case 4:
            result = a / b;
            break;
    }
    if ((result > 0) && (choice < 5))
        Console.WriteLine("Result: {0}", result);
    else
        Console.WriteLine("Invalid selection");
    Console.WriteLine("Do you want to enter another example? [Yes/No]");
    continue = Console.ReadLine();
}
Console.WriteLine("Thank you for using the calculator, you can close the application with any key.");
Console.ReadKey();

Všimnime si, že sme sa pri tomto variante s while museli zamyslieť nad východiskovou hodnotou premennej continue. Tej sme nastavili hodnotu "yes", aby podmienka bola splnená pre prvý prechod cyklom. Vymyslieť predvolenú hodnotu ale môže byť pomerne zložité a niekedy je potrebné použiť aj pomocnú premennú.

Variant s cyklom do - while

Keď použijeme cyklus do - while, predvolenú hodnotu danej premennej už nemusíme riešiť:

Console.WriteLine("Welcome to the calculator");
string continue;
do
{
    Console.WriteLine("Enter the first number:");
    float a = float.Parse(Console.ReadLine());
    Console.WriteLine("Enter the second number:");
    float b = float.Parse(Console.ReadLine());
    Console.WriteLine("Choose operation:");
    Console.WriteLine("1 - addition");
    Console.WriteLine("2 - subtraction");
    Console.WriteLine("3 - multiplication");
    Console.WriteLine("4 - division");
    int choice = int.Parse(Console.ReadLine());
    float result = 0;
    switch (choice)
    {
        case 1:
            result = a + b;
            break;
        case 2:
            result = a - b;
            break;
        case 3:
            result = a * b;
            break;
        case 4:
            result = a / b;
            break;
    }
    if ((choice > 0) && (choice < 5))
        Console.WriteLine("Result: {0}", result);
    else
        Console.WriteLine("Invalid selection");
    Console.WriteLine("Do you want to enter another example? [Yes/No]");
    continue = Console.ReadLine();
} while (continue == "Yes");

Console.WriteLine("Thank you for using the calculator, you can close the application with any key.");
Console.ReadKey();

break a continue

Niekedy je potrebné beh cyklu prerušiť. Na to nám slúžia nasledujúce dve kľúčové slová.

break

Príkaz break ukončuje aktuálny cyklus. Používa sa najčastejšie vtedy, keď pomocou cyklu nájdeme nejakú položku v kolekcii a ďalej už v jej prechádzaní nechceme pokračovať. Nebudeme tak ďalej zbytočne prehľadávať zvyšok kolekcie, pretože už máme to, čo sme hľadali.

Príklad

Predstavme si, že máme pole položiek a chceme v nich nejakú nájsť. Ponúka sa použiť metódu IndexOf() alebo Contains(). Pokiaľ pôjde o pole, bude použitie týchto metód vhodné, ale niektoré kolekcie ich nemajú alebo napríklad chceme hľadať pomocou inej vlastnosti, než ktorú tieto metódy zohľadňujú. Vyhľadávanie potom musíme buď napísať pekne ručne cyklom, alebo k nemu použiť výrazne pokročilejšie konštrukcie, než teraz ovládame.

Predstavme si, že máme veľké a malé štítky na poháre. Na všetky poháre chceme použiť buď jedny, alebo druhé štítky. Zaujíma nás teda, či sa text všetkých popiskov zmestí na malé štítky. Napíšeme program, ktorý zistí, či sa v poli nachádza slovo dlhšie ako 6 znakov. Pokiaľ áno, musíme použiť väčšie štítky.

Cyklom začneme prechádzať jednotlivé slová, a akonáhle nájdeme slovo dlhšie ako 6 znakov, uložíme si jeho index. Zatiaľ stále nič nové pod slnkom. V tej istej chvíli však cyklus pomocou príkazu break ukončíme.

Ukážka použitia príkazu break:

string[] fruitsList = {"Apples", "Pears", "Plums", "Apricots", "Strawberries", "Cherries"};
int searchedIndex = -1;

for (int i = 0; i < fruitsList.Length; i++)
{
    if (fruitsList[i].Length > 6)
    {
        searchedIndex = i;
        break;
    }
}

if (searchedIndex >= 0)
    Console.WriteLine("First word longer than 6 characters: " + fruitsList[searchedIndex]);

Výstup:

Konzolová aplikácia
First word longer than 6 characters: Apricots

Príkaz break sa v praxi často nahrádza príkazom return za predpokladu, že je kód v našej vlastnej metóde. Vlastné metódy sa ale naučíme deklarovať až v nadväzujúcom kurze Základy objektovo orientovaného programovania v C#. Príkaz break potom odporúčame skôr nepoužívať, správnejší variant je kód pre prácu s kolekciou vyčleniť do samostatnej funkcie.

continue

Príkaz continue je podobný ako break. Používa sa však na ukončenie iba aktuálnej iterácie (priebehu) cyklu, a nie celého cyklu. Cyklus potom rovno prechádza na ďalšiu iteráciu. Na použitie príkazu continue môžeme naraziť napr. pri validovaní položiek pri prechádzaní nejakej kolekcie.

Príklad

Predstavme si, že máme od užívateľa zadané čísla a tieto čísla chceme sčítať. Užívateľ tieto čísla zadá ako jeden reťazec, v ktorom je každé číslo oddelené čiarkou. Bohužiaľ musíme počítať aj s tým, že používateľ namiesto čísla zadá nejaký nezmysel. Riešenie by mohlo vyzerať nasledovne:

string stringNumbers = "10,50,abcd,30,9";
// splitting a string into an array
string[] arrayNumbers = stringNumbers.Split(',');
int sum = 0;
foreach (string number in arrayNumbers)
{
    // converting a string to an integer
    int integer;

    if(!int.TryParse(number, out integer))
        continue;

    sum += integer;
}
Console.WriteLine("The sum is: " + sum);

Výstup:

Konzolová aplikácia
The sum is: 99

Program spočíta všetky správne zadané hodnoty, teda tie, pri ktorých metóda TryParse() vrátila hodnotu true. Pri nesprávne zadaných hodnotách je aktuálna iterácia ukončená. Namiesto continue by sme samozrejme mohli použiť aj príkaz if, kód by sme tým však zbytočne vnorili.

Skrátený zápis cyklu for

Nasledujúce konštrukcie tu uvádzame iba pre ukážku, s čím všetkým je možné sa stretnúť v cudzích kódoch, a nie je dobrý nápad ich používať!

Cyklus for je možné zapísať takto skrátene, bez tela cyklu:

for (int i = 0; i < 10; Console.Write(i++));

Výstup:

Konzolová aplikácia
0123456789

Písať logiku priebehu behu cyklu aj logiku v cykle na jeden riadok ale nie je intuitívne. Navyše sa tak môže ľahko zabudnúť na inkrementáciu premennej, prípadne ju môžeme inkrementovať viackrát.

V hlavičke cyklu for dokonca nie je nutné uvádzať akýkoľvek príkaz:

for (;;)
{
    // endless loop
}

Tento zápis je rovnaký ako:

while (true)
{
    // endless loop
}

Oba vyššie deklarované cykly bežia donekonečna a môžete sa s nimi stretnúť v zle napísaných zdrojových kódoch spolu s príkazmi break, ktoré z nich potom za nejakých podmienok vyskakujú.

Akonáhle podmienka nie je priamo v deklarácii cyklu, je pomerne ťažké zistiť, kedy cyklus vôbec skončí. Z takého cyklu je potom ľahké vytvoriť nechtiac nekonečný. To platí obzvlášť vtedy, keď z cyklu vyskakujeme viacerými podmienkami a nepokryjeme všetky možné prípady.

Hoci dnešná lekcia obsahovala štandardnú gramatiku C#.NET pre cykly, z nových konštrukcií používajte iba do - while a continue. Prechodne ešte môžete používať break, než sa dostaneme k objektom

V nasledujúcom kvíze, Kvíz - Pokročilé podmienky a cykly v C# .NET, si vyskúšame nadobudnuté skúsenosti z predchádzajúcich lekcií.