ARCHIV

Perl (10) - Další řídící struktury

Podívejme se na některá klíčová slova, která mohou být používána v cyklech pro dodatečné řízení.

9.6.2005 07:00 | Jiří Václavík | Články autora | přečteno 35812×

last, next, redo

Existuje i jiný způsob, jak řídit cykly, než pomocí testu. Ve skutečnosti můžeme napsat nekonečný cyklus a ukončit ho až za určitých podmínek v jeho bloku. Cyklus tak vůbec nemusí celý řádně proběhnout. V minulém dílu jsme k tomuto účelu použili funkci die. Ta však nevyskočí jen z cyklu, ale přímo ukončí program. Následující informace platí pro všechny cykly, které zatím známe.

Klíčové slovo last uvedené v těle cyklu cyklus okamžitě ukončuje. Provádění programu pokračuje bezprostředně za cyklem (za uzavírací složenou závorkou).

Oproti tomu next přeskočí pouze zbytek bloku a provádění pokračuje další iterací (má stejnou funkci jako céčkovské continue).

U obou těchto klíčových slov je možný parametr, kterým je jméno návěští. To použijeme, pokud se provádí cyklus uvnitř jiného cyklu. Potom vyskočíme z obou.

Teď uveďme několik ukázek kódu, které většinou používají while. V praxi bychom použili u většiny nejspíše for. Cyklus while zde používáme spíše proto, že jsme se s for ještě dostatešně neobeznámili.

$i = 0;
while ($i < 9){
    $i++;
    if ($i == 5) {
        last;
    }
    print "Probíhá cyklus $i.\n";
}

Proběhne pouze 5 cyklů, protože v 5. cyklu je klíčovým slovem last cyklus ukončen a program pokračuje za blokem:

$ perl last.pl
Probíhá cyklus 1.
Probíhá cyklus 2.
Probíhá cyklus 3.
Probíhá cyklus 4.
$

Podobný program, jen s drobnou modifikací - vyměnímě last za next:

$i = 0;
while ($i < 9){
    $i++;
    if ($i == 5) {
        next;
    }
    print "Probíhá cyklus $i.\n";
}

Na začátku 5. cyklu je cyklus přerušen a pokračuje dalším cyklem. Proto není u 5. cyklu zaznamenán výpis:

$ perl while1.pl
Probíhá cyklus 1.
Probíhá cyklus 2.
Probíhá cyklus 3.
Probíhá cyklus 4.
Probíhá cyklus 6.
Probíhá cyklus 7.
Probíhá cyklus 8.
Probíhá cyklus 9.
$

Příkaz redo má stejný účinek jako next, jen nedojde ke změně počítadla. Jinými slovy skočíme znovu na začátek bloku.

for ($i=1; $i<10; $i++){
    $i++;
    if ($i == 4) {
        redo;
    }
    print "Probíhá cyklus $i.\n";
}

Při první iteraci je v bloku zvýšena hodnota $i na 2. V další iteraci je nejprve zvýšena v počítadle, dále v bloku a má hodnotu 4. To je důvod pro volání redo. Program přeskočí opět na začátek bloku, přičemž počítadlo hodnotu $i nemění. Ta se změní až v bloku. Aktuální hodnota je tedy 5 a od tohoto okamžiku už pokračuje skript, aniž by kdykoliv testu podmínky vyhověl.

$ perl while1.pl
Probíhá cyklus 2.
Probíhá cyklus 5.
Probíhá cyklus 7.
Probíhá cyklus 9.
$

Návěští

Další možností řídit cykly je pojmenovat blok a umístit za klíčové slovo last, next nebo redo právě název bloku (návěští). To musí být definováno. Před cyklus, pro který má návěští platit, se uvádí jeho název následovaný dvojtečkou. Návěští se pojmenovává velkými písmeny.

$i = 0;
NAVESTI:
while (){ #nekonečný cyklus
    while ($i < 10){
        print "Probíhá cyklus $i.\n";
        if ($i == 3){
        last NAVESTI;
        }

        $i++;
    }
}

last zde nevyskakuje z vnitřního cyklu, ale z cyklu označeného jako NAVESTI.

$ perl while1.pl
Probíhá cyklus 0.
Probíhá cyklus 1.
Probíhá cyklus 2.
Probíhá cyklus 3.
$

Dodejme, že návěští je vhodné používat z důvodu přehlednosti nejen v případě zanořených cyklů.

Blok continue

continue je nepovinným blokem příkazů na konci cyklu. Je spuštěn při každé iteraci mimo případů, kdy je cyklus přerušen klíčovým slovem redo nebo last. V následujícím příkladu je proměnná $i iterována i v případě, kdy je klíčovým slovem next přeskočeno na další iteraci. continue se proto hodí pro opakování kódu, které by muselo být vyvoláno v každé iteraci. Ovšem často místo použití continue stačí vyměnit cyklus while za for.

while ($i < 10){
    if ($i == 5){
        next;
    }
}continue{
    $i++; #blok continue je proveden vždy. I v případě, že $i == 5.
}

Klíčové slovo goto

goto funguje podobně jako návěští. Parametrem goto je opět návěští, které ale nepojmenovává blok. Může být uvedeno před libovolný příkaz. Po goto se bude dále vykonávat část programu, začínající návěštím.

print "1\n";

goto GOTO;

print "2\n";
print "3\n";

GOTO:

print "4\n";
print "5\n";

Druhé a třetí print nebude vykonáno. Když program narazí na goto, bude vše až po návěští přeskočeno:

$ perl goto.pl
1
4
5
$

Nic nám nebrání umístit návěští na goto před samotné goto.

print "1\n";
$i = 0;
GOTO:

print "2\n";
print "3\n";

$i++;
if ($i != 2){
    goto GOTO;
}
print "4\n";
print "5\n";

Nastává zajímavá situace. Po druhou inkrementaci je goto vynecháno, aby cyklus nebyl nekonečný. Všimněme si, že mluvíme o cyklu, aniž bychom použili while nebo for. Slovo cyklus je skutečně na místě, protože je část kódu vykonávána opakovaně. Pokud se trochu zamyslíme, zjistíte, že jde vlastně logicky o cyklus do...while, který je jen převlečený do jiného kabátu.

$ perl goto.pl
1
2
3
2
3
4
5
$

Přes tento hezký efekt ale doporučují programátoři goto používat jen ve výjimečných situacích, kdy by bylo jiné řešení značně složité. Je to jedna z mnoha dalších konstrukcí, jejíž přispěním program ztrácí na přehlednosti.

Příklad - hádání myšleného čísla

Napíšeme si jednoduchou hru. V ní si od nás program nejprve vyžádá číslo, které bude určovat horní hranici intervalu, ve kterém leží myšlené číslo. Potom bude opakovaně vyzývat k zadání čísla a prozradí vždy, zda je myšlené číslo větší nebo menší než hádané. Přitom bude počítat pokusy. V případě uhádnutí skončí cyklus.

Na začátku programu je nutné aktivovat generátor:

#!/usr/bin/perl 
use strict; 
use warnings; 

srand;

Dále získáme ze vstupu číslo:

my $max;
print "Zadej největší možné číslo: ";
chomp($max = <STDIN>);

Musíme podmínkou ošetřit případ, kdy je zadané číslo nekladné.

if (int $max <= 0){
    die "Toto není správně zadané číslo.\n";
}

Ještě stále nemáme myšlené číslo. Vygenerujeme ho funkcí rand. Je zde ale problém a možná tušíte jaký. rand vrací desetinné číslo a my chceme celé. Desetinnou část odřízneme funkcí int. To má za vedlejší efekt posunutí intervalu o jedničku dolů. Nemáme zájem, aby mohlo být tajné číslo 0, proto přičteme jedničku.

my $tajne_cislo = int(rand($max)) + 1;

Teď na řadu přijde samotný cyklus. V něm musí být výzva k zadání čísla a vyhodnocení - zda je menší, větší nebo rovno myšlenému číslu. Pokud je rovno, vypíšeme hlášku a ukončíme cyklus pomocí klíčového slova last.

while (1){
    print "Hádej číslo mezi 1 a $max.\n";
    my $hadane_cislo;
    chomp($hadane_cislo = <STDIN>);

    if ($hadane_cislo == $tajne_cislo){
        print "Gratuluji!\n";
        last;
    }elsif($hadane_cislo < $tajne_cislo){
        print "To je málo. ";
    }else{
        print "Moc. ";
    }
}

Na něco jsme přece jen zapomněli. Počítat pokusy. S výhodou použijeme blok continue. Před cyklem nastavíme číslo pokusu na 1

my $pokus = 1;

a bezprostředně za cyklus přidáme právě blok continue. V něm budeme přičítat pokusy.

continue{
    $pokus++;
}

Protože s počítáním pokusů dříve nepočítali, musíme upravit hlášku v případě uhodnutí tajného čísla:

print "Gratuluji, uhodl jsi na $pokus. pokus!\n";

Teď spusťme program.

$ ./cislo.pl
Zadej největší možné číslo: 100
Hádej číslo mezi 1 a 100.
50
To je málo. Hádej číslo mezi 1 a 100.
75
Moc. Hádej číslo mezi 1 a 100.
63
To je málo. Hádej číslo mezi 1 a 100.
69
To je málo. Hádej číslo mezi 1 a 100.
72
Moc. Hádej číslo mezi 1 a 100.
70
To je málo. Hádej číslo mezi 1 a 100.
71
Gratuluji, uhodl jsi na 7. pokus!
$

Zdrojový kód příkladu.

Verze pro tisk