ARCHIV

Perl (50) - Uzávěry a iterátory

Dnes si představíme jednu skrytou vlastnost anonymních podprogramů a následně ji aplikujeme na generování posloupností čísel.

11.1.2007 06:00 | Jiří Václavík | Články autora | přečteno 15390×

Uzávěr je speciální anonymní podprogram, který v době volání používá proměnné, jež už neexistují, ale existovaly v okamžiku, kdy byl tento podprogram definován.

Charakteristika uzávěrů

Ukážeme si nejprve několik příkladů, pomocí kterých pak uzávěry lépe popíšeme. Zde je první.

$r_s = sub {
    my $h = "uzaver";
    print $h;
};

&$r_s();

Vytisknut je řetězec "uzaver". To nikoho nemůže překvapit. Teď ale kód zmodifikujeme. Budeme vracet odkaz na podprogram, který definujeme v jiném podprogramu. Podprogram vrácený odkazem zároveň bude používat proměnnou deklarovanou v podprogramu, z něhož je odkaz na tento podprogram vrácen (a tedy v němž je tento podprogram deklarován).

sub f {
    my $h = "uzaver";
    return sub { print $h; }
}

$r_s = f();#$r_s obsahuje odkaz na podprogam vrácený podprogramem f
&$r_s();   #a zde tento odkaz dereferencujeme

$r_s teď obsahuje odkaz na vnořený podprogram. Dereferencujeme ho a voláme. Co ale dereferencovaný podprogram udělá? Měl by tisknout hodnotu proměnné $h. Ta ale byla platná jen v těle podprogramu f. V době jeho volání je nedefinovaná. Po ukončení podprogramu f by měli být všechny jeho lexikálně (pomocí my) deklarované proměnné zapomenuty.

Bude se tedy tisknout nedefinovaná hodnota? Je to překvapivé, ale nebude. Vytiskne se řetězec "uzaver", přestože v době volání ani v definici volaného podprogramu tento řetězec uveden není. Je pouze platný v době definice podprogramu. A právě o tom celé téma okolo uzávěrů je.

Anonymní podprogram má tu vlastnost, že si v paměti udržuje všechny proměnné, které ještě bude potřebovat. Po zavolání je pak takový anonymní podprogram schopen použít informaci, která byla platná v době definice. Právě to je případ proměné $h z příkladu.

Další důležitou skutečností je, že uzávěry fungují jen s lexikálně vymezenými proměnnými. S proměnnými deklarovanými pomocí local nebo přímo s globálními nemůže jít o uzávěr. Zkuste si v posledním úseku kódu zaměnit my za local, nebo ho přímo odstranit. Před samotným voláním změňte hodnotu tisknuté proměnné a uvidíte, že se tiskne právě tato hodnota.

Užití uzávěrů - iterátory

Anonymní podprogram vracený formou odkazu jiným podprogramem může být volán hned několikkrát. Dále je možné každým voláním hodnotu pamatované proměnné měnit. To je podstata iterátoru.

Pomocí iterátorů lze tvořit například posloupnosti čísel.

Posloupnost 2ⁿ

Vytvoříme si vzestupnou řadu čísel složenou z čísel 2ⁿ. Musíme zařídit, aby anonymní podprogram během každého volání

• vytiskl aktuální hodnotu pamatované proměnné
• a zároveň pamatovanou hodnotu změnil na hodnotu dvojnásobnou

Takto bude vypadat samotný generátor:

sub generuj_posloupnost_2_na_ntou {
    my($y) = 1;      #1. pamatovanou hodnotou bude hodnota 1.
                     #Každým voláním anonymního podprogramu se bude měnit.
    return sub {
        print "$y\n";#tiskne aktuální pamatovanou hodnotu
        $y *= 2;     #násobí pamatovanou hodnotu dvěma 

    }
}

Nyní zavoláme podprogram generuj_posloupnost_2_na_ntou. Tím získáme odkaz na podprogram.

Podprogram generuj_posloupnost_2_na_ntou už dále používán nebude. Dále už budeme volat jen získaný podprogram.

&$r_s(); #tiskne 1
&$r_s(); #tiskne 2
&$r_s(); #tiskne 4
&$r_s(); #tiskne 8

A tato volání můžeme třeba zacyklit.

for($i=0; $i<40; $i++){
    &$r_s();
}

Posloupnost xⁿ

Nyní příklad trochu modifikujeme. Místo řady 2ⁿ budeme generovat obecnější posloupnost xⁿ, přičemž $x bude zadáno.

Podprogram generuj_posloupnost_x_na_ntou se bude lišit hned v několika ohledech. Především - bude nutné si pamatovat 2 hodnoty - $n a $x. Jednotlivá volání budou měnit hodnotu $n, ale nikoliv hodnotu $x. Hodnota $x bude zas přijata jako argument. Generátor bude vypadat takto:

sub generuj_posloupnost_x_na_ntou {
    my($x) = shift;
    my $y = 1;
    return sub {
        print "$y\n";
        $y *= $x;
    }
}

A teď jsme v nové situaci. Můžeme vytvořit hned několik iterátorů!

$r_s1 = generuj_posloupnost_x_na_ntou(2);
$r_s2 = generuj_posloupnost_x_na_ntou(5);

Teď lze volat podprogramy &r_s1 a &r_s2. Každý má svůj vlastní generátor - a tedy svoji vlastní hodnotu pamatovaných proměnných $x a $y.

&$r_s2(); #      tiskne 1
&$r_s2(); #      tiskne 5
&$r_s1(); #tiskne 1
&$r_s1(); #tiskne 2
&$r_s1(); #tiskne 4
&$r_s2(); #      tiskne 25

Sdílení dat více iterátory

Dále je možné, aby více iterátorů sdílelo stejné pamatované proměnné. Je to vlastnost neobvyklá a stojí za to se nad ní zamyslet. Jde o to, že Perl umožňuje z jednoho generátoru vrátit seznam odkazů na anonymní podprogramy. Uveďme si opět příklad.

sub generuj_posloupnost {
    my $a = shift;

    return (
        sub {
            $a++;         #přičítá k pamatované hodnotě 1
            print "$a\n"; #tiskne aktuální pamatovanou hodnotu
        },
        sub {
            $a--;         #odečítá od aktuální hodnoty 1
            print "$a\n"; #tiskne aktuální pamatovanou hodnotu
        },
        sub {
            print "$a\n"; #tiskne aktuální pamatovanou hodnotu
        }
    );
}

($r_nahoru, $r_dolu, $r_tiskni) = generuj_posloupnost(0);

&$r_tiskni; #tiskne 0
&$r_nahoru;      #tiskne 1
&$r_nahoru;      #tiskne 2
&$r_nahoru;      #tiskne 3
&$r_dolu;   #tiskne 2
&$r_dolu;   #tiskne 1

Nyní přistupují podprogramy &$r_nahoru, &$r_dolu i &$r_tiskni ke stejné proměnné.

Verze pro tisk