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

V predchádzajúcej lekcii, Podmienky v C# - Ternárny výraz a prepadávací switch, sme sa venovali ďalšej syntaxi podmienok.

V dnešnom tutoriáli C# sa pozrieme na cyklus do - while, príkazy break a continue a tiež na skrátený zápis už prebraného cyklu for.

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

Cyklus 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 tabulátor. Zvyšok cyklu sa dopíše sám.

Príklad

Použitie cyklu do - while si ukážeme 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 our calculator");
string goOn = "yes";
while (goOn == "yes")
{
    Console.WriteLine("Enter the first number:");
    double a = double.Parse(Console.ReadLine());
    Console.WriteLine("Enter the second number:");
    double b = double.Parse(Console.ReadLine());
    Console.WriteLine("Choose one of the following operations:");
    Console.WriteLine("1 - addition");
    Console.WriteLine("2 - subtraction");
    Console.WriteLine("3 - multiplication");
    Console.WriteLine("4 - division");
    int option = int.Parse(Console.ReadLine());
    double result = 0;
    switch (option)
    {
        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 ((option > 0) && (option < 5))
        Console.WriteLine("Result: {0}", result);
    else
        Console.WriteLine("Invalid option");
    Console.WriteLine("Would you like to make another calculation? [yes/no]");
    goOn = Console.ReadLine();
}
Console.WriteLine("Thank you for using our calculator. Press any key to end the program.");
Console.ReadKey();

Všimnime si, že sme sa pri tomto variante s while museli zamyslieť nad východiskovou hodnotou premennej goOn. Tej sme nastavili hodnotu "yes", aby bola podmienka 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 goOn;
do
{
    Console.WriteLine("Enter the first number:");
    double a = double.Parse(Console.ReadLine());
    Console.WriteLine("Enter the second number:");
    double b = double.Parse(Console.ReadLine());
    Console.WriteLine("Choose one of the following operations:");
    Console.WriteLine("1 - addition");
    Console.WriteLine("2 - subtraction");
    Console.WriteLine("3 - multiplication");
    Console.WriteLine("4 - division");
    int option = int.Parse(Console.ReadLine());
    double result = 0;
    switch (option)
    {
        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 ((option > 0) && (option< 5))
        Console.WriteLine("Result: {0}", result);
    else
        Console.WriteLine("Invalid option");
    Console.WriteLine("Would you like to make another calculation? [yes/no]");
    goOn = Console.ReadLine();
} while (goOn == "Yes");

Console.WriteLine("Thank you for using our calculator. Press any key to end the program.");
Console.ReadKey();

Príkazy break a continue

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

Príkaz 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 s využitím break

Predstavme si, že máme pole položiek a chceme v nich nejakú nájsť. Môžeme použiť metódu IndexOf() alebo Contains(). Pokiaľ pôjde o pole, tak 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 použiť výrazne pokročilejšie konštrukcie, ako 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 popisov zmestí na malé štítky. Napíšeme program, ktorý zistí, či sa v poli nachádza slovo dlhšie ako 6 znakov. Ak á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 Objektovo orientované programovanie v C# .NET. Príkaz break potom odporúčame skôr nepoužívať, správnejšie je kód na prácu s kolekciou vyčleniť do samostatnej funkcie.

Príkaz 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 s využitím continue

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ť takto:

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 ako ukážku, aby sme vedeli, s čím všetkým sa môžeme stretnúť v cudzích kódoch, a nie je dobrý nápad ich používať!

Cyklus for môžeme zapísať skrátene takto, 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, kým 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í.