Provided by: manpages-pl_0.7-1_all bug

NAZWA

       perlref - odwołania i zagnieżdżone struktury danych w Perlu

UWAGA

       To jest pełna dokumentacja dotycząca wszelkich aspektów odwołań.  Krótszy, wprowadzający
       wstęp to najistotniejszych cech znajdziesz w podręczniku perlreftut(1).

OPIS

        Uwaga! To tłumaczenie może być nieaktualne!

       Przed wersją 5 Perla przedstawianie złożonych struktur danych było trudne, gdyż wszystkie
       odwołania musiały być symboliczne -- a nawet wtedy ciężko było odnosić się do zmiennej
       zamiast do pozycji w tablicy symboli.  Obecnie Perl nie tylko ułatwia posługiwanie się
       symbolicznymi odwołaniami do zmiennych, ale także pozwala na użycie "stałych" odwołań
       (hard references) do dowolnego kawałka danych lub kodu. Stałe dowiązanie może być
       przechowywane w dowolnym skalarze. Ponieważ tablice i tablice asocjacyjne (hasze)
       zawierają skalary, to możesz teraz łatwo budować tablice tablic, tablice haszy, hasze
       tablic, tablice haszy funkcji i tak dalej.

       Odwołania stałe są sprytne -- utrzymują za ciebie liczniki odwołań, automatycznie
       zwalniając rzecz, do której odnosi się odwołanie, jeśli jej licznik odwołań zejdzie do
       zera. (Uwaga: liczniki odwołań dla wartości w strukturach danych odnoszących się do samych
       na siebie (self-referential) lub strukturach cyklicznych mogą nie schodzić do zera bez
       pewnej drobnej pomocy; patrz sekcja Two-Phased Garbage Collection w podręczniku
       perlobj(1), zawierająca bardziej szczegółowy opis.)  Jeśli taka rzecz jest obiektem, to
       obiekt jest niszczony. Więcej o obiektach znajdziesz w podręczniku perlobj(1). (W pewnym
       sensie, wszystko w Perlu jest obiektem, ale zwykle rezerwujemy to słowo dla odwołań do
       obiektów, które zostały oficjalnie "pobłogosławione" ("blessed") [tj.zakwalifikowane jako
       obiekty] w pakiecie klasy.)

       Odwołania symboliczne są nazwami zmiennych lub innych obiektów; zupełnie tak jak
       dowiązania symboliczne (symbolic links) w uniksowym systemie plików zawierają wyłącznie
       nazwę pliku. Notacja *glob jest rodzajem odwołania symbolicznego.  (Odwołania symboliczne
       nazywane są czasami "soft references" [odwołaniami miękkimi, w przeciwieństwie do "hard
       r."-"twardych"], ale proszę nie nazywaj ich tak; odwołania są wystarczająco zbijające z
       pantałyku bez zbędnych synonimów.)

       W przeciwieństwie do nich, odwołania stałe przypominają dowiązania stałe (hard links)
       uniksowego systemu plików: służą do udostępniania obiektu bez zwracania uwagi na to, jaka
       jest jego (inna) nazwa. Tam, gdzie użyto słowa "odwołanie" bez przymiotnika, jak w
       poniższym akapicie, mówi się zwykle o odwołaniu stałym.

       W Perlu odwołania są łatwe w użyciu. Jest tylko jedna nadrzędna zasada: Perl nie wykonuje
       niejawnego odwoływania bądź dereferowania odwołań.  [Dereferencing: odniesienie się z
       powrotem do obiektu, rzeczy na którą wskazuje odwołanie].  Gdy skalar przechowuje
       odwołanie, to zawsze zachowuje się jak zwykły skalar.  Nie zaczyna magicznie być tablicą,
       haszem czy procedurą; musisz wprost nakazać takie zachowanie, wykonując dereferencję.

       Tworzenie odwołań

       Odwołania mogą być tworzone na kilka sposobów.

       1.  Przez zastosowanie operatora odwróconego ukośnika do zmiennej, procedury lub wartości.
           (Działa to bardzo podobnie do operatora & (zwracającego adres) w języku C.) Zauważ, że
           konstrukcja ta tworzy KOLEJNE odwołanie do zmiennej, gdyż w tablicy symboli istnieje
           już odwołanie do tej zmiennej.  Jednak odwołanie z tablicy symboli może zniknąć, a
           nadal będziesz mieć odwołanie, które zwrócił odwrócony ukośnik. Oto kilka przykładów:

               $scalarref = \$foo;
               $arrayref  = \@ARGV;
               $hashref   = \%ENV;
               $coderef   = \&handler;
               $globref   = \*foo;

           Przy użyciu operatora odwróconego ukośnika nie jest możliwe utworzenie prawdziwego
           odwołania do uchwytu IO (uchwytu pliku lub katalogu).  Możesz co najwyżej uzyskać
           odwołanie do typeglob będącego faktycznie pełnym wpisem w tablicy symboli. (Przeczytaj
           jednak poniżej objaśnienie składni *foo{COŚ}.) Mimo to, możesz nadal używać typeglob i
           odwołań do nich jakby były one uchwytami IO.

       2.  Odwołanie do anonimowej tablicy można stworzyć posługując się nawiasami kwadratowymi:

               $arrayref = [1, 2, ['a', 'b', 'c']];

           Utworzyliśmy odwołanie do anonimowej tablicy trzech elementów, której ostatni element
           jest z kolei odwołaniem do innej anonimowej tablicy trzech elementów.  (Dostęp do niej
           umożliwi opisana dalej składnia tablic wielowymiarowych.  Na przykład, dla powyższego
           przykładu $arrayref->[2][1] zwraca wartość "b".)

           Zauważ, że stworzenie odwołania do listy wyliczanej nie jest tym samym, co użycie
           nawiasów kwadratowych. Jest to natomiast tym samym, co stworzenie listy odwołań!

               @list = (\$a, \@b, \%c);
               @list = \($a, @b, %c);      # to samo!

           W przypadku szczególnym, \(@foo) zwraca listę odwołań do zawartości @foo, nie zaś
           odwołanie do samej @foo. Podobnie jest dla %foo, z wyjątkiem tego, że odwołania-klucze
           odnoszą się do kopii (gdyż klucze są łańcuchami znakowymi, a nie dowolnymi skalarami).

       3.  Odwołanie do anonimowej tablicy asocjacyjnej (hasza) można utworzyć używając nawiasów
           klamrowych:

               $hashref = {
                   'Adam'  => 'Ewa',
                   'Clyde' => 'Bonnie',
               };

           Powyższe konstruktory anonimowych haszy i tablic można swobodnie łączyć.  Umożliwia to
           otrzymywanie dowolnie skomplikowanych struktur.  Opisana składnia wielowymiarowych
           tablic/haszy działa także dla nich.  Wartości w powyższym przykładzie były literałami,
           ale równie dobrze mogłyby być zmiennymi czy wyrażeniami, gdyż perlowe operatory
           przypisania (nawet wewnątrz local() czy my()) są wykonywalnymi instrukcjami, a nie
           jedynie deklaracjami dla fazy kompilacji.

           Ponieważ nawiasy klamrowe służą do kilku innych rzeczy, a także do tworzenia BLOKów,
           możesz być czasem zmuszony do uniknięcia dwuznaczności tych nawiasów na początku
           instrukcji. Wystarczy wówczas umieszczenie przed nimi + lub return, by Perl
           zorientował się, że otwierający nawias klamrowy nie rozpoczyna BLOKu. Oszczędność i
           zalety mnemoniczne użycia nawiasów klamrowych warte są takiego sporadycznego
           zamieszania.

           Na przykład, jeśli chciałbyś, by funkcja tworzyła nowy hasz i zwracała odwołanie do
           niego, to masz takie możliwości:

               sub hashem {        { @_ } }   # źle, ale bez komunikatu o błędzie
               sub hashem {       +{ @_ } }   # ok
               sub hashem { return { @_ } }   # ok

           Z drugiej strony, jeśli chcesz drugiego znaczenia nawiasów (blok), zrób tak:

               sub showem {        { @_ } }   # dwuznaczne (obecnie ok, ale może się zmienić)
               sub showem {       {; @_ } }   # ok
               sub showem { { return @_ } }   # ok

           Zwróć uwagę, że początkowe +{ i {; zawsze służą do wykluczenia dwuznaczności
           wyrażenia, aby znaczyło albo odwołanie do HASZa albo BLOK.

       4.  Można utworzyć odwołanie do anonimowej procedury używając sub bez nazwy procedury:

               $coderef = sub { print "Bums!\n" };

           Zwróć uwagę na obecność średnika.  Poza faktem, że wewnętrzny kod nie jest wykonywany
           natychmiast, sub {} jest bardziej operatorem niż deklaracją, podobnie zresztą jak do{}
           czy eval{}.  (Jednak, niezależnie od tego, ile razy wykonasz powyższą linię (chyba że
           jesteś wewnątrz eval("...")), $coderef wciąż będzie zawierać odwołanie do TEJ SAMEJ
           anonimowej procedury.)

           Procedury anonimowe działają jak zamknięcia (closures) w odniesieniu do zmiennych
           my(), to znaczy, zmiennych widocznych leksykalnie w bieżącym zakresie. Zamknięcie jest
           pojęciem ze świata Lispa, mówiącym, że jeśli zdefiniujesz anonimową funkcję w
           konkretnym kontekście leksykalnym, to będzie ona działać w tym kontekście nawet jeśli
           została wywołana poza nim.

           Mówiąc po ludzku, jest to zabawny sposób przesyłania argumentów do procedury zarówno
           gdy ją definiujesz jak i wtedy gdy ją wywołujesz. Przydaje się to do tworzenia małych
           fragmentów kodu do późniejszego uruchamiania, jak np. wywołania wsteczne (callbacks).
           Przy ich pomocy możesz robić nawet rzeczy zorientowane obiektowo, choć Perl zapewnia
           już odmienny mechanizm operowania obiektami --patrz podręcznik perlobj(1).

           Możesz również myśleć o zamknięciach jak o sposobie pisania szablonów bez używania
           eval. (Faktycznie, w wersji 5.000, eval było jedyną metodą uzyskania zamknięć. Jeśli
           posługujesz się zamknięciami, możesz potrzebować "require 5.001".)

           A to mały przykład tego, jak działają zamknięcia:

               sub newprint {
                   my $x = shift;
                   return sub { my $y = shift; print "$x, $y!\n"; };
               }
               $h = newprint("Howdy");
               $g = newprint("Greetings");

               # czas mija...

               &$h("world");
               &$g("earthlings");

           Drukuje to

               Howdy, world!
               Greetings, earthlings!

           Zwróć uwagę szczególnie na to, że $x nadal odnosi się do wartości przesłanej do
           newprint(), mimo że zmienna "my $x" pozornie wyszła poza swój zakres, w momencie gdy
           wywołano anonimową procedurę. O to właśnie chodzi w zamknięciu.

           Przy okazji: odnosi się do tylko do zmiennych leksykalnych. Zmienne dynamiczne
           działają nadal tak jak zawsze. Zamknięcie nie jest czymś, o co musiałaby się martwić
           większość programistów Perla.

       5.  Odwołania często zwracane są przez specjalne procedury zwane konstruktorami.  Obiekty
           w Perlu są po prostu odwołaniami do specjalnego rodzaju obiektu, który wie z którym
           pakietem jest związany. Konstruktory są specjalnymi procedurami, które wiedzą jak
           utworzyć to powiązanie.  Robią to zaczynając od zwykłego odwołania, i pozostaje ono
           zwykłym odwołaniem nawet wtedy gdy jest równocześnie obiektem. Konstuktory często
           nazywane są new() i wywoływane nie wprost:

               $objref = new Psisko (Ogon => 'krótki', Uszy => 'długie');

           Ale nie muszą być:

               $objref   = Psisko->new(Ogon => 'krótki', Uszy => 'długie');

               use Term::Cap;
               $terminal = Term::Cap->Tgetent( { OSPEED => 9600 });

               use Tk;
               $main    = MainWindow->new();
               $menubar = $main->Frame(-relief              => "raised",
                                       -borderwidth         => 2)

       6.  Odwołania odpowiedniego typu mogą być powoływane do istnienia jeśli dereferencjonujesz
           je w kontekście zakładającym, że istnieją. Ponieważ jeszcze nie mówiliśmy o
           dereferencji, nie możemy na razie pokazać przykładów.

       7.  Odwołanie może być utworzone przy pomocy specjalnej składni, uroczo zwanej składnią
           *foo{COŚ}.  *foo{COŚ} zwraca odwołanie do przegródki COŚ w *foo (które jest pozycją w
           tablicy symboli przechowującą wszystko znane jako foo.)

               $scalarref = *foo{SCALAR};
               $arrayref  = *ARGV{ARRAY};
               $hashref   = *ENV{HASH};
               $coderef   = *handler{CODE};
               $ioref     = *STDIN{IO};
               $globref   = *foo{GLOB};

           Wszystkie powyższe wyrażenia są oczywiste, z wyjątkiem *foo{IO}.  Zwraca ono uchwyt
           IO, używany jako uchwyt pliku (patrz opis open w podręczniku perlfunc(1)), gniazdo
           (opis socket oraz socketpair w perlfunc(1)) lub uchwyt katalogu (opendir w
           perlfunc(1)). Dla zgodności z poprzednimi wersjami Perla, *foo{UCHWYTPLIKU} jest
           synonimem *foo{IO}.

           *foo{COŚ} zwraca undef jeśli dane COŚ jeszcze nie było używane, z wyjątkiem dla
           skalarów. Jeśli nie używano jeszcze $foo, *foo{SKALAR} zwraca odwołanie do anonimowego
           skalara.  W przyszłych wersjach może się to zmienić.

           *foo{IO} jest alternatywą dla mechanizmu \*UCHWYTU opisanego w sekcji Typeglobs and
           Filehandles podręcznika perldata(1), a służącego do przesyłania uchwytów plików do i z
           procedur lub przechowywania w większych strukturach danych. Jego wadą jest to, że nie
           utworzy za Ciebie nowego uchwytu pliku. Zaletą zaś, że nie ryzykujesz więcej niż
           zamierzałeś przy przypisaniem typeglob, choć jeśli wykonasz przypisanie do skalara
           zamiast do typeglob, to też dobrze.

               splutter(*STDOUT);
               splutter(*STDOUT{IO});

               sub splutter {
                   my $fh = shift;
                   print $fh "her um well a hmmm\n";
               }

               $rec = get_rec(*STDIN);
               $rec = get_rec(*STDIN{IO});

               sub get_rec {
                   my $fh = shift;
                   return scalar <$fh>;
               }

       Posługiwanie się odwołaniami

       To tyle o tworzeniu odwołań. Teraz pewnie nie możesz się doczekać wiedzy jak posługiwać
       się odwołaniami, by móc wrócić do swych leżących odłogiem danych.  Oto kilka podstawowych
       sposobów.

       1.  Wszędzie, gdzie postawiłbyś identyfikator (lub łańcuch identyfikatorów) jako część
           nazwy zmiennej czy procedury, możesz zastąpić identyfikator prostą zmienną skalarną
           zawierającą odwołanie poprawnego typu:

               $bar = $$scalarref;
               push(@$arrayref, $nazwapliku);
               $$arrayref[0] = "styczeń";
               $$hashref{"KLUCZ"} = "WARTOŚĆ";
               &$coderef(1,2,3);
               print $globref "wynik\n";

           Ważne jest, by zrozumieć, że nie NIE wykonujemy tu specjalnie dereferencji
           $arrayref[0] czy $hashref{"KLUCZ"}.  Dereferencja zmiennej skalarnej odbywa się PRZED
           przeszukaniem klucza (indeksu tablicy). Wszystko bardziej skomplikowane niż
           dereferencja prostej zmiennej skalarnej wymaga użycia niżej opisanych metod 2 lub 3.
           Jednak określenie "prosty skalar" obejmuje też identyfikator, który sam używa
           rekurencyjnie metody 1. Zatem poniższe drukuje "witaj".

               $refrefref = \\\"witaj";
               print $$$$refrefref;

       2.  Wszędzie, gdzie postawiłbyś identyfikator (lub łańcuch identyfikatorów) jako część
           nazwy zmiennej czy procedury, możesz zastąpić identyfikator BLOKiem zwracającym
           odwołanie poprawnego typu. Inaczej mówiąc, poprzednie przykłady mogą zostać zapisane
           tak:

               $bar = ${$scalarref};
               push(@{$arrayref}, $nazwapliku);
               ${$arrayref}[0] = "styczeń";
               ${$hashref}{"KLUCZ"} = "WARTOŚĆ";
               &{$coderef}(1,2,3);
               $globref->print("wynik\n");  # jeśli załadowano IO::Handle

           Niewątpliwie, użycie nawiasów klamrowych w tym przypadku nie jest zbyt mądre, ale BLOK
           może zawierać dowolne wyrażenie, w szczególności wyrażenia indeksowane:

               &{ $dispatch{$index} }(1,2,3);      # wywołaj właściwą obsługę

           Z powodu możliwości pomijania nawiasów klamrowych dla prostych przypadków $$x, ludzie
           często popełniają błąd postrzegania symboli dereferencji jako prawdziwych operatorów i
           zastanawiają się nad ich priorytetem.  Gdyby nimi były, mógłbyś używać zwykłych
           nawiasów zamiast klamrowych.  Tak jednak nie jest. Rozważ poniższą różnicę: przypadek
           0 jest skróconą wersją przypadku 1, NIE przypadku 2:

               $$hashref{"KLUCZ"}   = "WARTOŚĆ";       # przypadek 0
               ${$hashref}{"KLUCZ"} = "WARTOŚĆ";       # przypadek 1
               ${$hashref{"KLUCZ"}} = "WARTOŚĆ";       # przypadek 2
               ${$hashref->{"KLUCZ"}} = "WARTOŚĆ";     # przypadek 3

           Przypadek 2 jest również mylący, gdyż odnosi się do zmiennej o nazwie %hashref, nie
           zaś dereferencjonuje poprzez $hashref hasza, na który wydawałoby się wskazuje skalar.
           To robi przypadek 3.

       3.  Wywołania procedur i poszukiwanie poszczególnych elementów tablic pojawiają się
           wystarczająco często, by zastosowanie do nich metody 2 stało się niewygodne.  Jako
           formę "osłodzenia składni", przykłady z metody 2 można zapisać:

               $arrayref->[0] = "styczeń";        # element tablicy
               $hashref->{"KLUCZ"} = "WARTOŚĆ";   # element hasza
               $coderef->(1,2,3);                 # wywołanie procedury

           Lewa strona strzałki może być dowolnym wyrażeniem zwracającym odwołanie, łącznie z
           uprzednią dereferencją. [Ułatwia to operowanie odwołaniami do zmiennych zawierających
           kolejne odwołania, jak poniżej].  Zauważ, że $array[$x] NIE jest tu tym samym co
           $array->[$x]:

               $array[$x]->{"foo"}->[0] = "styczeń";

           Jest to jeden z przypadków wspomnianych wcześniej, gdzie odwołania zaistnieją, gdy
           zostaną użyte w kontekście l-wartości. Przed tą instrukcją, element $array[$x] mógł
           być niezdefiniowany. W takim przypadku, jest on definiowany automatycznie z nadaniem
           mu wartości -- odwołania do hasza, tak że możemy poszukiwać w haszu elementu o kluczu
           "foo".  Podobnie klucz $array[$x]->{"foo"} zostanie automatycznie zdefiniowany z
           równoczesnym nadaniem wartości -- odwołania do tablicy, zatem będzie można w niej
           odnaleźć [0]. Proces ten zwany jest autovivification (automatyczne ożywianie).

           Jeszcze jedno. POMIĘDZY indeksami umieszczonymi w nawiasach klamrowych strzałka jest
           opcjonalna, zatem możemy skrócić powyższy zapis do:

               $array[$x]{"foo"}[0] = "styczeń";

           Co, w szczególnym przypadku działania tylko na zwykłych tablicach, daje tablice
           wielowymiarowe z zapisem jak w C:

               $score[$x][$y][$z] += 42;

           No dobrze, tak naprawdę, nie całkiem jak tablice w C. C nie wie, jak poszerzać tablice
           na żądanie. Perl to potrafi.

       4.  Jeżeli odwołanie jest odwołaniem do obiektu, to prawdopodobnie istnieją metody dostępu
           do wskazywanych przez nie rzeczy, i powinieneś zapewne z nich skorzystać, chyba że
           jesteś w pakiecie klasy definiującej metody tego obiektu i pracujesz nad nimi.
           Inaczej mówiąc, bądź tak dobry i nie naruszaj hermetyzacji bez istotnego powodu. Perl
           nie wymusza hermetyzacji. Nie jesteśmy tu totalitarystami.  Oczekujemy jednak
           zachowania podstawowych zasad uprzejmości.

       Można posłużyć się operatorem ref() do stwierdzenia, na jaki typ rzeczy wskazuje
       odwołanie. Zobacz podręcznik perlfunc(1).

       Operator bless() może być używany do powiązania obiektu, na który wskazuje odwołanie, z
       pakietem funkcjonującym jako klasa obiektowa.  Zobacz podręcznik perlobj(1).

       Typeglob może być dereferencjowane w ten sam sposób jak odwołanie, gdyż składnia
       dereferencji zawsze wskazuje na pożądany rodzaj odwołania.  Zatem ${*foo} i ${\$foo}
       wskazują na tę samą zmienną skalarną.

       A oto sztuczka do interpolacji wywołania procedury w łańcuchu:

           print "Procedura mysub tym razem zwróciła @{[mysub(1,2,3)]} .\n";

       Działa to w tak, że gdy @{...} znalezione zostanie wewnątrz łańcucha w cudzysłowach to
       zostanie potraktowane jako blok. Blok ten tworzy odwołanie do jednoelementowej anonimowej
       tablicy zawierającej wynik wywołania mysub(1,2,3) [odwołanie to utworzone będzie dzięki
       nawiasom kwadratowym].  Zatem cały blok zwraca odwołanie do tablicy, która następnie
       podlega dereferencji powodowanej przez @{...}. Jej wartość, jako umieszczona w łańcuchu w
       cudzysłowach podlega interpolacji w napis.  Takie szykany przydają się także w dowolnych
       wyrażeniach:

           print "That yields @{[$n + 5]} widgets\n";

       Odwołania symboliczne

       Powiedzieliśmy, że niezdefiniowane cele odwołania w razie potrzeby zaistnieją [podczas
       dereferencji].  Nie mówiliśmy jednak, co się dzieje, gdy wartość użyta jako odwołanie jest
       już zdefiniowana, ale NIE JEST odwołaniem stałym. Jeżeli użyjesz odwołania w takim
       przypadku, to będzie ono potraktowane jak odwołanie symboliczne. To znaczy, wartością
       skalara zostanie NAZWA zmiennej a nie bezpośrednie dowiązanie do (być może anonimowej)
       wartości.

       Niektórzy często spodziewają się, że działa to jakoś tak. I rzeczywiście.

           $name = "foo";
           $$name = 1;                 # ustawia $foo
           ${$name} = 2;               # ustawia $foo
           ${$name x 2} = 3;           # ustawia $foofoo
           $name->[0] = 4;             # ustawia $foo[0]
           @$name = ();                # czyści @foo
           &$name();                   # wywołuje &foo() (jak w Perl 4)
           $pack = "THAT";
           ${"${pack}::$name"} = 5;    # ustawia $THAT::foo bez rozwinięcia(eval)

       Jest to bardzo silne narzędzie, ale nieco niebezpieczne, gdyż możliwe jest, ze szczerym
       zamiarem użycia odwołania stałego, przypadkowe użycie symbolicznego. Możesz się przed tym
       uchronić pisząc:

           use strict 'refs';

       a dla reszty otaczającego bloku będą dozwolone tylko odwołania stałe.  Wewnętrzny blok
       może się temu sprzeciwić przy pomocy

           no strict 'refs';

       Dla odwołań symbolicznych widoczne są tylko zmienne pakietu (globalne, nawet jeśli
       lokalnie). Zmienne leksykalne (deklarowane przy pomocy my()) nie zawierają się w tablicy
       symboli, zatem są niewidoczne dla tego mechanizmu.  Na przykład:

           local $wartosc = 10;
           $ref = "wartosc";
           {
               my $wartosc = 20;
               print $$ref;
           }

       Nadal będzie drukować 10, a nie 20. Pamiętaj, że local() działa na zmienne pakietu, które
       dla samego pakietu wszystkie są "globalne".

       Odwołania niezbyt symboliczne

       Nową cechą poprawiającą czytelność, wprowadzoną w perlu wersji 5.001, jest to, że nawiasy
       wokół odwołania symbolicznego zachowują się jak znaki cudzysłowu, czyli tak, jakby zawsze
       zawierały wewnątrz łańcuch. To znaczy, że

           $push = "pop on ";
           print "${push}over";

       miało zawsze znaczenie wydrukowania "pop on over", bez względu na fakt, że "push" jest
       słowem zarezerwowanym. Zostało to uogólnione tak, by działać również poza cudzysłowami,
       zatem

           print ${push} . "over";

       a nawet

           print ${ push } . "over";

       mają ten sam rezultat. (Spowodowałoby to błąd składni w Perlu 5.000, choć Perl 4 dopuszcza
       coś takiego w postaci bez odstępów.) Zauważ, że konstrukcja ta nie nie jest uważana za
       odwołanie symboliczne gdy używasz strict refs:

           use strict 'refs';
           ${ bareword };      # dobrze, znaczy $bareword.
           ${ "bareword" };    # błąd, odwołanie symboliczne.

       Podobnie, z powodu wszelkiego indeksowania przy pomocy pojedynczych słów, zastosowaliśmy
       tę samą regułę do każdego z gołych słów użytego do indeksowania hasza. Zatem teraz,
       zamiast

           $array{ "aaa" }{ "bbb" }{ "ccc" }

       możesz napisać po prostu

           $array{ aaa }{ bbb }{ ccc }

       i nie martwić się o to, czy indeksy są słowami zarezerwowanymi. W tych rzadkich
       przypadkach, gdy chcesz zrobić coś w rodzaju

           $array{ shift }

       możesz wymusić interpretację słowa jako zarezerwowanego dodając cokolwiek, co zrobi zeń
       więcej niż gołe słowo:

           $array{ shift() }
           $array{ +shift }
           $array{ shift @_ }

       Przełącznik -w będzie Cię ostrzegał, jeśli zinterpretuje słowo zarezerwowane jako łańcuch.
       Nie będzie jednak ostrzegał o użyciu słów pisanych małymi literami, gdyż łańcuch jest
       faktycznie cytowany.

       Pseudo-hasze: Używanie tablicy jak hasza

       OSTRZEŻENIE:  Niniejsza sekcja opisuje cechę eksperymentalną.  W przyszłych wersjach
       szczegóły mogą ulec zmianie bez powiadomienia.

       Począwszy od Perla 5.005 możesz w pewnych kontekstach posługiwać się odwołaniem do
       tablicy, mimo że normalnie wymagają one odwołania do hasza.  Pozwala to na dostęp do
       elementów tablicy przy użyciu nazw symbolicznych, tak jakby były one polami struktury.

       Żeby to zadziałało tablica musi zawierać dodatkową informację. Pierwszym elementem tablicy
       powinno być odwołanie do hasza odwzorowującego nazwy pól na indeksy tablicy. Oto przykład:

          $struct = [{foo => 1, bar => 2}, "FOO", "BAR"];

          $struct->{foo};  # to samo, co $struct->[1], tj. "FOO"
          $struct->{bar};  # to samo, co $struct->[2], tj. "BAR"

          keys %$struct;   # zwróci ("foo", "bar") w jakiejś kolejności
          values %$struct; # zwróci ("FOO", "BAR") w jakiejś kolejności

          while (my($k,$v) = each %$struct) {
              print "$k => $v\n";
          }

       Jeśli spróbujesz usunąć klucze z takiego pseudo-hasza lub będziesz próbował sięgnąć do
       nieistniejących pól, perl zgłosi wyjątek.  W celu poprawy wydajności, Perl może też
       wykonać na etapie kompilacji tłumaczenie nazw pól na odpowiadające im indeksy tablicy dla
       opisanych odwołań.  Patrz  podręcznik fields(3).

       Szablony funkcji

       Jak wyjaśniono powyżej, zamknięcie jest anonimową funkcją z dostępem do zmiennych
       leksykalnych widocznych podczas jej kompilacji. Zachowuje ona dostęp do tych zmiennych
       nawet wtedy, gdy jest wykonywana później, tak jak funkcja obsługi sygnału (signal handler)
       czy wywołanie wsteczne Tk.

       Posługiwanie się zamknięciem jako szablonem funkcji umożliwia tworzenie wielu podobnie
       działających funkcji. Załóżmy, że potrzebujesz funkcji o nazwach pochodzących od różnych
       kolorów zmieniających czcionkę HTML.

           print "Hej, ", red("uważaj"), "na to ", green("światło");

       Funkcje red() i green() będą bardzo podobne. By je stworzyć, przypiszemy zamknięcie do
       typeglob nazwy funkcji, którą próbujemy skonstruować.

           @kolory = qw(red blue green yellow orange purple violet);
           for my $nazwa (@kolory) {
               no strict 'refs';       # pozwól na operowanie tablicą symboli
               *$nazwa = *{uc $nazwa} = sub { "<FONT COLOR='$nazwa'>@_</FONT>" };
           }

       Teraz wszystkie te funkcje będą istnieć niezależnie od siebie. Możesz wywoływać red(),
       RED(), blue(), BLUE(), green(), etc. Technika ta zarówno skraca czas kompilacji jak i
       zmniejsza zużycie pamięci, jest też mniej narażona na błędy, gdyż kontrola składni odbywa
       się podczas kompilacji. Istotne jest, by wszelkie zmienne w anonimowej procedurze były
       zmiennymi leksykalnymi by stworzyć poprawne zamknięcie. Z tego powodu użyto my dla
       zmiennej sterującej pętli.

       Jest to jedno z jedynych miejsc, gdzie dostarczenie prototypu do zamknięcia ma sens. Jeśli
       chciałbyś narzucić kontekst skalarny dla argumentów powyższych, przykładowych funkcji
       (pewnie nie najlepszy pomysł w tym przypadku), możesz zapisać to inaczej:

           *$nazwa = sub ($) { "<FONT COLOR='$nazwa'>$_[0]</FONT>" };

       Jednakże, ponieważ sprawdzanie protypów odbywa się podczas kompilacji, powyższe
       przypisanie zostanie wykonane za późno, by było przydatne. Mógłbyś to obejść przez
       włożenie całej pętli przypisań do wnętrza bloku BEGINu, wymuszając wykonanie go w czasie
       kompilacji.

       Dostęp do zmiennych leksykalnych zmieniających typ -- jak te w pętli for powyższego
       przykładu-- działa wyłącznie z zamknięciami, a nie z procedurami w ogóle. Zatem w
       przypadku ogólnym, procedury nazwane nie zagnieżdżają się prawidłowo, choć robią to
       procedury anonimowe.  Jeśli nawykłeś do używania zagnieżdżonych procedur z własnymi
       prywatnymi zmiennymi w innych językach programowania, to w Perlu będziesz musiał nad
       trochę popracować. Intuicyjna metoda kodowania tego typu rzeczy spowoduje tajemnicze
       ostrzeżenia ``will not stay shared'' (nie pozostanie wspólne).  To, na przykład, nie
       zadziała:

           sub zewn {
               my $x = $_[0] + 35;
               sub wewn { return $x * 19 }   # ŹLE
               return $x + wewn();
           }

       Obejście jest następujące:

           sub zewn {
               my $x = $_[0] + 35;
               local *wewn = sub { return $x * 19 };
               return $x + wewn();
           }

       Teraz wewn() może być wywołana tylko z wnętrza zewn(), z powodu tymczasowego przypisania
       zamknięcia (procedury anonimowej). Ale kiedy jest wywoływana, to ma zwykły dostęp do
       zmiennej leksykalnej $x z zakresu procedury zewn().

       Ma to interesujący skutek tworzenia funkcji lokalnych względem innych funkcji, co
       normalnie nie jest obsługiwane w Perlu.

OSTRZEŻENIE

       Nie możesz (w użyteczny sposób) posłużyć się odwołaniem jako kluczem hasza.  Zostanie ono
       zamienione na łańcuch:

           $x{ \$a } = $a;

       Jeśli spróbujesz zdereferencjonować klucz, nie otrzymasz odwołania stałego a łańcuch i nie
       uzyskasz tego, co próbowałeś. W zamian można napisać coś podobnego do:

           $r = \@a;
           $x{ $r } = $r;

       a następnie użyć values(), co zwróci rzeczywiste odwołania, zamiast użycia keys(), gdyż
       klucze odwołaniami nie będą.

       Standardowy moduł Tie::RefHash umożliwia wygodny sposób obejścia tego problemu.

ZOBACZ TAKŻE

       Poza oczywistą dokumentacją, pouczająca może być analiza kodu źródłowego.  Kilka raczej
       patologicznych przykładów użycia odwołań znajdziesz w teście regresji t/op/ref.t w
       katalogu źródeł Perla.

       Zobacz również podręczniki perldsc(1) i perllol(1), opisujące posługiwanie się odwołaniami
       do tworzenia złożonych struktur danych, oraz perltoot(1), perlobj(1) i perlbot(1)
       opisujące ich użycie do tworzenia obiektów.

INFORMACJE O TŁUMACZENIU

       Powyższe tłumaczenie pochodzi z nieistniejącego już Projektu Tłumaczenia Manuali i może
       nie być aktualne. W razie zauważenia różnic między powyższym opisem a rzeczywistym
       zachowaniem opisywanego programu lub funkcji, prosimy o zapoznanie się z oryginalną
       (angielską) wersją strony podręcznika za pomocą polecenia:

              man --locale=C 1 perlref

       Prosimy o pomoc w aktualizacji stron man - więcej informacji można znaleźć pod adresem
       http://sourceforge.net/projects/manpages-pl/.