Provided by: manpages-pl_20060617-2_all bug

NAZWA

       perldata - typy danych Perla

OPIS

       Nazwy zmiennych

       Perl posiada trzy typy struktur danych: skalary, tablice skalarów oraz
       asocjacyjne tablice skalarów, zwane też "haszami" ("hashes").  Zwykłe
       tablice indeksowane są liczbami, począwszy od 0 (indeksy ujemne są
       liczone od końca tablicy). Tablice asocjacyjne indeksowane są
       łańcuchami.

       Wartości są zwykle przypisane do nazwy (lub nazwanego odwołania).
       Pierwszy znak nazwy mówi o tym, do jakiego rodzaju struktury danych się
       ona odnosi. Reszta nazwy określa konkretną wartość, do której odnosi
       się nazwa.  Najczęściej składa się ona z pojedynczego identyfikatora,
       to znaczy, łańcucha rozpoczynającego się literą lub znakiem
       podkreślenia i zawierającego litery, podkreślenia i cyfry. W niektórych
       przypadkach może być ciągiem identyfikatorów, rozdzielonych przez ::
       (lub przez ', ale nie jest to polecane). Wszystkie oprócz ostatniego
       interpretowane są jako nazwy pakietów, wskazując przestrzenie nazw, w
       których będzie wyszukiwany ostatni identyfikator (szczegóły znajdziesz
       w sekcji Packages podręcznika perlmod(1)).  Możliwe jest zastąpienie
       prostego identyfikatora wyrażeniem, które w czasie wykonania tworzy
       odwołanie do wartości; jest to opisane szczegółowo poniżej oraz na
       stronie perlref(1) podręcznika.

       Istnieją również zmienne specjalne, których nazwy nie przestrzegają
       powyższych reguł, po to by nie kolidowały przypadkowo z którąś z twych
       zwykłych zmiennych.  Łańcuchy, które pasują do objętych nawiasami
       okrągłymi części wyrażenia regularnego zachowywane są pod nazwami
       zawierającymi tylko cyfry po znaku $ (patrz strony perlop(1) i
       perlre(1) dokumentacji).  Dodatkowo, kilka zmiennych specjalnych,
       umożliwiających dostęp do wewnętrznych rozwiązań Perla, posiada nazwy
       zawierające znaki przestankowe (zobacz strony perlvar(1) dokumentacji).

       Wartości skalarne zawsze noszą nazwy rozpoczynające się znakiem '$',
       nawet, gdy odnoszą się do skalara będącego częścią tablicy. Działa to
       podobnie jak angielski przedimek "the".  A zatem mamy:

           $dni             # zwykła wartość skalarna "dni"
           $dni[28]         # 29-ty element tablicy
           $dni{'luty'}     # wartość dla klucza 'luty' z hasza %dni
           $#dni            # ostatni indeks tablicy @dni

       ale całe tablice lub wycinki tablic oznaczane są przez '@', co działa
       jak angielskie słowo "these" lub "those":

           @dni             # ($dni[0], $dni[1],... $dni[n])
           @dni[3,4,5]      # to samo, co @dni[3..5]
           @dni{'a','c'}    # to samo, co ($dni{'a'},$dni{'c'})

       zaś całe tablice asocjacyjne (hasze) oznaczane są przez '%':

           %dni             # (klucz1, wartość1, klucz2, wartość2 ...)

       Dodatkowo, procedury nazywane są z użyciem początkowego '&', choć jest
       to opcjonalne, jeśli nie jest dwuznaczne (tak jak w języku angielskim
       często zbyteczne jest użycie słowa"do").  Elementy tablicy symboli mogą
       być nazywane z użyciem początkowego '*', ale na razie nie musisz się
       tym zajmować.

       Każdy typ zmiennych ma swoją własną przestrzeń nazw. Możesz, bez obawy
       o konflikt, używać tej samej nazwy dla zmiennej skalarnej, tablicy czy
       tablicy asocjacyjnej (lub uchwytu pliku, nazwy procedury czy etykiety).
       Oznacza to, że $foo i @foo są dwoma różnymi zmiennymi. Znaczy to też,
       że $foo[1] jest częścią tablicy @foo, nie zaś częścią skalara $foo.
       Może się to wydawać trochę dziwne, ale tak ma być, gdyż to jest dziwne.

       Ponieważ odniesienia do zmiennych i tablic zawsze rozpoczynają się od
       '$', '@' lub '%', to słowa "zarezerwowane" nie są naprawdę
       zarezerwowane w odniesieniu do nazw zmiennych.  (Jednak SĄ one
       zarezerwowane w odniesieniu do etykiet i uchwytów plików, które nie
       posiadają specjalnego początkowego znaku. Nie możesz, na przykład, użyć
       uchwytu pliku o nazwie "log". Wskazówka: możesz napisać
       open(LOG,'logfile') zamiast open(log,'logfile').  Użycie nazw uchwytów
       plików złożonych z dużych liter poprawia również czytelność i chroni
       przed konfliktami z przyszłymi słowami zastrzeżonymi.  Wielkość liter
       JEST znacząca--"FOO", "Foo" oraz "foo" są zupełnie innymi nazwami.
       Nazwy rozpoczynające się literą lub znakiem podkreślenia mogą zawierać
       również cyfry i podkreślenia.

       Możliwe jest zastąpienie takiej alfanumerycznej nazwy wyrażeniem, które
       zwraca odwołanie do obiektu danego typu. Opis tego znajdziesz na
       stronie perlref(1) podręcznika.

       Nazwy rozpoczynające się cyfrą mogą zawierać tylko cyfry. Nazwy, które
       nie zaczynają się od litery, podkreślenia ani cyfry ograniczone są do
       pojedynczego znaku, np. $% czy $$. (Większość z tych jednoznakowych
       nazw ma predefiniowane znaczenie dla Perla. Na przykład, $$ jest
       identyfikatorem bieżącego procesu.)

       Kontekst

       Interpretacja operacji i wartości w Perlu zależy czasami od wymagań
       kontekstu, w jakim użyta jest operacja czy wartość. Istnieją dwa główne
       konteksty: skalarny i listowy. Niektóre z operacji zwracają wartości
       listowe w kontekście oczekującym listy, zaś wartości skalarne w
       przeciwnym przypadku.  (Jeśli tak jest dla danej operacji, to zostanie
       to wspomniane w jej opisie.)  Innymi słowy, Perl przeciąża pewne
       operacje w oparciu o to, czy spodziewana jest pojedyncza wartość czy
       mnoga. (W podobny sposób funkcjonują w języku angielskim niektóre
       słowa, jak "fish" czy "sheep".)

       Na zasadzie wzajemności, operacja dostarcza albo kontekstu skalarnego
       albo listowego każdemu ze swych argumentów. Na przykład, jeśli
       napiszesz

           int( <STDIN> )

       to operacja całkowita (integer) dostarcza kontekst skalarny dla
       operatora <STDIN>, który odpowiada czytając jeden wiersz z STDIN i
       przesyłając go z powrotem do operacji integer. Ta z kolei znajduje
       wartość typu integer tego wiersza i zwraca ją. Jeżeli, z drugiej
       strony, napiszesz

           sort( <STDIN> )

       To operacja sortowania dostarcza kontekstu listowego dla <STDIN>, który
       będzie przetwarzać wszystkie dostępne wiersze aż do końca pliku.
       Następnie prześle listę tych wierszy z powrotem do procedury
       sortowania, która z kolei posortuje dostarczone wiersze i zwróci je w
       postaci listy do kontekstu w jakim wywołano sort.

       Przypisanie jest trochę specyficzne, w tym, iż posługuje się swym lewym
       argumentem do ustalenia kontekstu dla prawego argumentu. Przypisanie do
       skalara oblicza prawą stronę w kontekście skalarnym, podczas gdy
       przypisanie do tablicy lub wycinka tablicy rozwija prawą stronę w
       kontekście listowym.  Przypisanie do listy również oblicza prawą stronę
       w kontekście listowym.

       Procedury definiowane przez użytkownika mogą sprawdzać, czy są wywołane
       w kontekście skalarnym czy listowym, ale większość z nich nie dba o to,
       gdyż skalary są automatycznie interpolowane w listy. Zobacz opis
       funkcji wantarray na stronie perlfunc(1).

       Wartości skalarne

       Wszystkie dane w Perlu są skalarami lub tablicami skalarów albo haszami
       skalarów. Zmienne skalarne mogą zawierać różne rodzaje pojedynczych
       danych, jak liczby, łańcuchy znakowe czy odwołania. Ogólnie, konwersja
       z jednej postaci na drugą jest transparentna. (Skalar nie może zawierać
       wielu wartości, ale może zawierać odwołanie do tablicy czy hasza
       zawierających wiele wartości.)  Z powodu automatycznej konwersji
       skalarów, operatory i funkcje zwracające skalary nie muszą dbać o to (i
       faktycznie nie dbają), czy kontekst oczekuje łańcucha czy też liczby.

       Skalary nie są koniecznie tą czy inną rzeczą. Nie ma możliwości
       zadeklarowania zmiennej skalarnej o typie "string", "number", typu
       "filehandle", czy jakiegoś innego. Perl jest językiem kontekstowo
       polimorficznym, w którym skalary mogą być łańcuchami, liczbami czy
       odwołaniami (co obejmuje obiekty). Łańcuchy i liczby uważane są za
       mniejwięcej to samo w niemal każdym zastosowaniu. Odwołania są jednak
       nierzutowalnymi wskaźnikami o ściśle określonym typie, z wbudowanym
       licznikiem odwołań i wywołaniami destruktora.

       Wartość skalarna interpretowana jest jako prawda, TRUE, w sensie logiki
       boolowskiej, jeśli nie jest łańcuchem pustym ani liczbą zero (lub jej
       łańcuchowym równoważnikiem, "0"). Kontekst boolowski (logiczny) jest po
       prostu specyficznym rodzajem kontekstu skalarnego.

       Faktycznie istnieją dwie odmiany skalarów pustych: zdefiniowane i
       niezdefiniowane. Niezdefiniowane skalary puste zwracane są gdy brak
       jest rzeczywistej wartości czegoś, jak w przypadku wystąpienia błędu
       lub na końcu pliku, albo gdy odwołujesz się do niezdefiniowanej
       zmiennej czy elementu tablicy. Niezdefiniowany pusty skalar może stać
       się zdefiniowany po tym, jak po raz pierwszy użyjesz go tak, jakby był
       zdefiniowany. Ale przed tym możesz posłużyć się operatorem defined(),
       by stwierdzić, czy wartość jest zdefiniowana czy też nie.

       By stwierdzić, czy dany łańcuch jest poprawną liczbą niezerową
       wystarczy zwykle porównać go zarówno z numerycznym 0 jak i leksykalnym
       "0" (choć spowoduje to ostrzeżenia opcji -w). Sposób ten wynika stąd,
       że łańcuchy nie będące liczbami uważane są za 0, tak jak w awk:

           if ($str == 0 && $str ne "0")  {
               warn "To nie wygląda na liczbę";
           }

       Zwykle jest to metoda preferowana, gdyż w przeciwnym razie nie
       traktowałbyś poprawnie notacji IEEE, takich jak NaN czy Infinity.
       Czasami będziesz wolał posłużyć się funkcją POSIX::strtod czy
       wyrażeniem regularnym do sprawdzenia, czy dana jest numeryczna.
       Dokładny opis wyrażeń regularnych znajdziesz w podręczniku perlre.

           warn "has nondigits"        if     /\D/;
           warn "not a natural number" unless /^\d+$/;              # odrzuca -3
           warn "not an integer"       unless /^-?\d+$/;            # odrzuca +3
           warn "not an integer"       unless /^[+-]?\d+$/;
           warn "not a decimal number" unless /^-?\d+\.?\d*$/;    # odrzuca .2
           warn "not a decimal number" unless /^-?(?:\d+(?:\.\d*)?|\.\d+)$/;
           warn "not a C float"
               unless /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;

       Długość tablicy jest wartością skalarną. Możesz uzyskać długość tablicy
       @dni obliczając $#dni, tak jak w csh.  (Faktycznie, nie jest to długość
       tablicy, a indeks ostatniego elementu, gdyż (zwykle) istnieje element o
       indeksie zerowym.) Przypisanie do $#dni zmienia długość tablicy.
       Skracanie tą metodą tablicy niszczy wartości pozostałe za nowym końcem
       tablicy. Wydłużenie uprzednio skróconej tablicy JUŻ NIE odtwarza
       wartości, które były w utraconych elementach. (Było tak w Perlu 4, ale
       musieliśmy z tym skończyć, by zapewnić wywoływanie destruktorów tam,
       gdzie jest to oczekiwane.)  Możesz też osiągnąć nieco lepszą
       efektywność wstępnie poszerzając tablicę, która ma się powiększyć.
       (Można także poszerzać tablicę wykonując przypisanie do elementu, który
       jest poza jej obecnym końcem.) Tablicę można obciąć do zera przez
       przypisanie do niej pustej listy (). Poniższe są równoważne:

           @cokolwiek = ();
           $#cokolwiek = -1;

       Jeżeli przetwarzasz nazwaną tablicę w kontekście skalarnym, to zwraca
       on długość tablicy. (Zauważ, że nie jest to prawdą dla list, które
       zwracają ostatnią wartość, tak jak operator przecinka w C. Nie jest to
       też prawdą dla funkcji wbudowanych, zwracających to, na co mają
       ochotę.)  Poniższe jest zawsze prawdziwe:

           scalar(@cokolwiek) == $#cokolwiek - $[ + 1;

       [Zmienna specjalna $[ określa indeks pierwszego elementu w tablicy i
       pierwszego znaku w łańcuchu, domyślnie jest to zero.]  W wersji 5 Perla
       zmieniono semantykę $[: pliki nie ustawiające wartości $[ nie muszą już
       zważać na to, czy inny plik zmienił jej wartość.  Inaczej mówiąc, nie
       zaleca się używania $[.  Zatem ogólnie możesz zakładać, że

           scalar(@cokolwiek) == $#cokolwiek + 1;

       Niektórzy programiści wybierają użycie jawnej konwersji, by nie było
       żadnych wątpliwości:

           $liczba_elementow = scalar(@cokolwiek);

       Jeżeli posługujesz się haszem (tablicą asocjacyjną) w kontekście
       skalarnym, to zwraca on wartość, która jest prawdą wtedy i tylko wtedy,
       gdy hasz zawiera jakąkolwiek parę klucz/wartość. (Jeżeli są takie pary,
       to wartość zwracana jest łańcuchem składającym się z liczby użytych
       jednostek komórek (buckets) oraz liczby zaalokowanych jednostek
       komórek, rozdzielonych ukośnikiem.  Najbardziej przydaje się to do
       sprawdzania, czy wkompilowany w Perl algorytm haszowania działa kiepsko
       na twoim zestawie danych. Na przykład, wrzucasz 10,000 elementów do
       hasza, ale przetworzenie %HASH w kontekście skalarnym zwraca "1/16", co
       oznacza, że tylko jedna z szesnastu komórek została użyta, i
       przypuszczalnie zawiera wszystkie twoje 10,000 pozycji. To się nie
       powinno zdarzyć.)

       Możesz wstępnie przydzielić miejsce na hasz przy pomocy przypisania do
       funkcji keys(). Zaokrągli to zaalokowane jednostki komórek do
       najbliższej potęgi dwójki.

           keys(%users) = 1000;                # zaalokuj 1024 buckets

       Konstruktory wartości skalarnych

       Literały numeryczne podawane są w zwyczajowych formatach
       zmiennoprzecinkowych lub całkowitych:

           12345
           12345.67
           .23E-10
           0xffff           # hex
           0377             # ósemkowa
           4_294_967_296    # podkreślenie dla lepszej czytelności

       Literały łańcuchowe ograniczone są zwykle przez pojedyncze lub podwójne
       cudzysłowy. Działają one bardzo podobnie do znaków cytowania powłoki: w
       literałach łańcuchowych w cudzysłowach zachodzi zastępowanie zmiennych
       i interpretacja odwrotnego ukośnika. W łańcuchach w apostrofach nie
       występuje zastępowanie i interpretacja (z wyjątkiem "\'" oraz "\\"). To
       tworzenia znaków takich jak nowa linia, tabulator itd., stosowane są
       zarówno zwykłe reguły użycia odwrotnego ukośnika w Unixie, jak i
       bardziej egzotyczne formy. Listę sposobów cytowania znajdziesz w sekcji
       Quote and Quotelike Operators podręcznika perlop(1).

       Zapisy ósemkowe czy szesnastkowe w literałach łańcuchowych (np.
       '0xffff') nie są automatycznie zamieniane na ich całkowitą
       reprezentację. Konwersje te wykonują funkcje hex() i oct(). Więcej
       szczegółów znajdziesz w opisach tych funkcji w podręczniku perlfunc(1).

       Możesz też umieszczać znaki nowej linii bezpośrednio w łańcuchach, tj.,
       mogą one kończyć się w innym wierszu niż się rozpoczęły. Jest to
       przyjemne, ale jeżeli zapomnisz zamykającego cudzysłowu, to błąd nie
       będzie zgłaszany dopóty, dopóki Perl nie znajdzie innego wiersza,
       zawierającego znak cudzysłowu, który może znajdować się o wiele dalej w
       skrypcie. Zastępowanie zmiennych w łańcuchach ograniczone jest do
       zmiennych skalarnych, tablic oraz wycinków tablic. (Inaczej mówiąc,
       nazw rozpoczynających się od $ lub @, po których może opcjonalnie
       wystąpić, ujęte w nawiasy kwadratowe, wyrażenie traktowane jako indeks
       elementu tablicy.)  Poniższy fragment kodu drukuje "Cena wynosi $100."

           $cena = '$100';    # nie interpretowane
           print "Cena wynosi $cena.\n";     # interpretowane

       Tak jak w niektórych powłokach, możesz umieścić nazwę w nawiasach
       klamrowych, by oddzielić ją od następujących dalej znaków
       alfanumerycznych.  Identyfikator w takich nawiasach traktowany jest
       zawsze jako łańcuch, tak samo jak pojedynczy identyfikator będący
       indeksem hasza. Nasz wcześniejszy przykład,

           $dni{'luty'}

       może być zapisany jako

           $dni{luty}

       a cudzysłowy będą domniemane automatycznie. Ale cokolwiek bardziej
       skomplikowanego w indeksie zostanie zinterpretowane jako wyrażenie.

       Zauważ, że łańcuch w pojedynczych cudzysłowach musi być oddzielony od
       poprzedzającego go słowa odstępem, gdyż pojedynczy cudzysłów jest
       poprawnym (choć nie zalecanym) znakiem w nazwie zmiennej (zobacz
       Packages w podręczniku perlmod(1)).

       Trzema specjalnymi literałami są __FILE__, __LINE__ oraz __PACKAGE__,
       które reprezentują nazwę bieżącego pliku, numer wiersza oraz nazwę
       pakietu w danym punkcie twego programu. Mogą być używane wyłącznie jako
       odrębne tokeny. Nie będą one interpolowane wewnątrz łańcuchów.  Jeżeli
       nie ma bieżącego pakietu (z powodu pustej dyrektywy package;), to
       __PACKAGE__ jest wartością niezdefiniowaną.

       Tokenami __END__ i __DATA__ można posługiwać się do wskazania
       logicznego końca skryptu przed faktycznym końcem pliku. Dowolny
       następujący po nich tekst jest ignorowany, ale może być odczytany przy
       pomocy uchwytu DATA. Wykorzystaj main::DATA dla użytego tokenu __END__,
       lub też NAZWAPAKIETU::DATA (gdzie NAZWAPAKIETU jest bieżącym pakietem)
       dla __DATA__.  Dwa znaki sterujące: ^D i ^Z są synonimami dla __END__
       (lub __DATA__ w module). Szerszy opis __DATA__ i przykład użycia
       znajdziesz w podręczniku SelfLoader.  Zauważ, że nie można czytać z
       uchwytu pliku DATA w bloku BEGIN.  Blok ten jest wykonywany natychmiast
       po napotkaniu (w czasie kompilacji).  W tym momencie nie został jeszcze
       znaleziony odpowiedni token __DATA__ (lub __END__).

       Słowo nie posiadające żadnej innej interpretacji w gramatyce Perla
       będzie traktowane tak, jakby znajdowało się w cudzysłowie. Są one znane
       pod nazwą "gołych słów" ("barewords").  Tak samo, jak w przypadku
       etykiet i uchwytów plików, gołe słowa składające się wyłącznie z małych
       liter narażają na konlikt z przyszłymi słowami zastrzeżonymi.  Jeżeli
       użyjesz przełącznika -w, to Perl będzie ostrzegał o wystąpieniu takich
       słów.  Niektórzy chcieliby całkowicie wyjąć spod prawa gołe słowa.
       Jeśli napiszesz

           use strict 'subs';

       to każde gołe słowo, które nie zostanie zinterpretowane jako wywołanie
       procedury spowoduje błąd kompilacji. Ograniczenie to rozciąga się do
       końca zawierającego je bloku. Blok wewnętrzny może je jednak zanegować
       przy pomocy no strict 'subs'.

       Zmienne tablicowe w łańcuchach objętych cudzysłowami interpolowane są
       przez złączenie wszystkich elementów tablicy. Elementy są wówczas
       rozdzielone ogranicznikiem podanym w zmiennej $" ($LIST_SEPARATOR w
       module English), domyślnie spacją. Poniższe fragmenty są równoważne:

           $temp = join($",@ARGV);
           system "echo $temp";

           system "echo @ARGV";

       Wewnątrz wzorców wyszukiwania (które również podlegają zastępowaniu w
       podwójnym cytowaniu) pojawia się brzydka niejednoznaczność: czy
       /$foo[bar]/ ma być interpretowane jako /${foo}[bar]/ (gdzie [bar] jest
       klasą znaków wyrażenia regularnego) czy też jako /${foo[bar]}/ (gdzie
       [bar] jest indeksem tablicy @foo)? Jeżeli nie istnieje @foo, to jest to
       oczywiście klasa znaków. Jeżeli @foo istnieje, to Perl odgaduje czym ma
       być [bar], i prawie zawsze ma rację.  Jeśli odgaduje źle, albo po
       prostu jesteś paranoikiem, możesz wymusić poprawną interpretację
       używając nawiasów klamrowych jak powyżej.

       Wierszowa forma cytowania oparta jest na składni "dokumentów-tutaj"
       używanej ("here-doc") w powłokach. Po sekwencji << podajesz napis
       ograniczający cytowany materiał, a wszystkie wiersze poniżej bieżącego
       aż do napisu kończącego są wartością elementu. Napisem kończącym może
       być identyfikator (słowo) albo jakiś cytowany tekst. Jeżeli jest to
       tekst cytowany, to rodzaj zastosowanych znaków cytowania określa
       traktowanie tekstu, tak jak przy zwykłym cytowaniu. Niecytowany
       identyfikator działa tak, jakby był w podwójnym cudzysłowie. Pomiędzy
       << a identyfikatorem nie może wystąpić spacja. (Jeżeli wstawisz spację,
       to będzie ona traktowany jak pusty identyfikator, co jest poprawne i
       dopasowuje pierwszy pusty wiersz.) Napis kończący musi pojawić się w
       wierszu kończącym samotnie (niecytowany i bez otaczających białych
       znaków).

               print <<EOF;
           Cena wynosi $cena.
           EOF

               print <<"EOF";  # to samo, co powyżej
           Cena wynosi $cena.
           EOF

               print <<`EOC`;  # wykonaj polecenia
           echo hi there
           echo lo there
           EOC

               print <<"foo", <<"bar"; # możesz składować, jeden za drugim
           I said foo.
           foo
           I said bar.
           bar

               myfunc(<<"TO", 23, <<'TAMTO');
           Masz tu linijkę
           czy dwie.
           TO
           a tu jeszcze jedną.
           TAMTO

       Nie zapomnij tylko, że musisz postawić średnik na końcu instrukcji.
       Perl nie wie przecież, czy nie zamierzasz spróbować zrobić tego:

               print <<ABC
           179231
           ABC
               + 20;

       Konstruktory wartości listowych

       Wartości listowe oznaczane są przez oddzielenie pojedynczych wartości
       przecinkami (i otoczenie listy nawiasami jeśli wymaga tego kolejność):

           (LIST)

       W kontekście nie wymagającym wartości listowej wartość literału
       listowego jest wartością ostatniego elementu, tak jak w przypadku
       występującego w C operatora przecinkowego.  Na przykład,

           @foo = ('cc', '-E', $bar);

       przypisuje wartość całej listy do tablicy foo, ale

           $foo = ('cc', '-E', $bar);

       przypisuje zmiennej foo wartość zmiennej bar. Zauważ, że rzeczywista
       tablica w kontekście skalarnym zwraca długość tablicy. Poniższy kod
       przypisuje $foo wartość 3:

           @foo = ('cc', '-E', $bar);
           $foo = @foo;                # $foo dostaje 3

       Przed nawiasem zamykającym listę literałów możesz użyć opcjonalnego
       przecinka, zatem możesz pisać:

           @foo = (
               1,
               2,
               3,
           );

       LISTY dokonują automatycznej interpolacji podlist. To znaczy, kiedy
       przetwarzana jest LISTA, to każdy jej element jest przetwarzany w
       kontekście listowym. Wynikowa wartość listy interpolowana jest do listy
       LISTA tak, jakby każdy pojedynczy element był członkiem LISTY Zatem w
       LIŚCIE tracą swoją tożsamość tablice i hasze--lista

           (@foo,@bar,&SomeSub,%glarch)

       zawiera wszystkie elementy @foo, po których następują wszystkie
       elementy @bar, wszystkie elementy zwrócone przez procedurę o nazwie
       SomeSub wywołaną w kontekście listowym, i na końcu pary klucz/wartość z
       %glarch. Jeżeli chcesz odwołać się do listy, NIE wykonując interpolacji
       zajrzyj do podręcznika perlref(1).

       Lista pusta reprezentowana jest przez (). Jej interpolowanie w liście
       nie daje żadnego efektu. Zatem ((),(),()) jest równoważne (). Podobnie,
       interpolowanie tablicy bez elementów jest tym samym, co nie
       interpolowanie w tym miejscu żadnej tablicy.

       Wartość listowa może być też indeksowana tak, jak zwykła tablica.
       Musisz tylko umieścić listę w nawiasach, by uniknąć niejasności. Na
       przykład:

           # Stat zwraca wartość listową
           $time = (stat($file))[8];

           # TUTAJ BŁĄD SKŁADNI
           $time = stat($file)[8];  # Oj, zapomniałem nawiasów

           # znajdź cyfrę szesnastkową
           $hexdigit = ('a','b','c','d','e','f')[$digit-10];

           # "reverse comma operator"
           return (pop(@foo),pop(@foo))[0];

       W liście możesz wykonać przypisanie do undef. Przydaje się to do
       pozbywania się niektórych wartości zwracanych przez funkcję:

           ($dev, $ino, undef, undef, $uid, $gid) = stat($file);

       Do list można wykonać przypisanie wtedy i tylko wtedy, gdy dozwolone
       jest przypisanie do każdego z elementów listy:

           ($a, $b, $c) = (1, 2, 3);

           ($map{'czerwony'}, $map{'niebieski'}, $map{'zielony'})
                                                     = (0x00f, 0x0f0, 0xf00);

       Przypisanie tablicy w kontekście skalarnym zwraca liczbę elementów
       utworzonych przez wyrażenie po prawej stronie przypisania:

           $x = (($foo,$bar) = (3,2,1));  # ustaw $x na 3, nie 2
           $x = (($foo,$bar) = f()); # ustaw $x na ilość zwróconych przez f()

       Jest to bardzo wygodne, gdy chcesz wykonać przypisanie listy w
       kontekście logicznym (boolowskim), gdyż większość funkcji listowych
       zwraca po zakończeniu przetwarzania listę pustą, co przy przypisaniu
       daje 0, interpretowane jako fałsz.

       Ostatni element może być tablicą lub haszem:

           ($a, $b, @rest) = split;
           my($a, $b, %rest) = @_;

       Faktycznie możesz umieścić tablicę lub hasza w dowolnym miejscu listy,
       ale pierwsze z nich na liście wessie wszystkie wartości i pozostałe
       dostaną wartość nul. Może to być pomocne w local() lub my().

       Literał hasza (tablicy asocjacyjnej) zawiera pary wartości, które będą
       interpretowane jako klucz i wartość:

           # takie samo przypisanie jak powyżej
           %map = ('czerwony',0x00f,'niebieski',0x0f0,'zielony',0xf00);

       Choć listy literałów i nazwane tablice są zwykle wzajemnie wymienne, to
       nie zachodzi to w przypadku haszy. To, że możesz indeksować wartości
       listy tak jak zwykłej tablicy nie oznacza, że możesz indeksować listę
       tak jak hasz.  Podobnie, hasze włączone jako części innych list
       (łącznie z listami parametrów i list zwracanych przez funkcje) zawsze
       ulegają spłaszczeniu do par klucz/wartość. Dlatego czasem dobrze jest
       użyć wskazania.

       Często bardziej czytelne jest użycie pomiędzy parami klucz/wartość
       operatora =>. Operator ten jest po prostu bardziej wyróżniającym się
       wzrokowo synonimem przecinka. Ponadto powoduje, że jego lewostronny
       operand jest interpretowany jako łańcuch, jeśli jest on gołym słowem,
       które mogłoby być poprawnym identyfikatorem.  Uprzyjemnia to
       inicjowanie haszy:

           %map = (
                        czerwony  => 0x00f,
                        niebieski => 0x0f0,
                        zielony   => 0xf00,
          );

       lub inicjowanie odwołań do haszy, które będą używane jako rekordy:

           $rec = {
                       witch => 'Mable the Merciless',
                       cat   => 'Fluffy the Ferocious',
                       date  => '10/31/1776',
           };

       albo użycie wywoływanych przez nazwę parametrów skomplikowanej funkcji:

          $field = $query->radio_group(
                      name      => 'group_name',
                      values    => ['eenie','meenie','minie'],
                      default   => 'meenie',
                      linebreak => 'true',
                      labels    => \%labels
          );

       Zwróć uwagę na to, iż fakt, że tablica asocjacyjna jest zainicjowana w
       takim porządku, nie oznacza, że zostanie zwrócona w tym samym porządku.
       Przykłady, jak ułożyć kolejność zwracanych wyników znajdziesz przy
       opisie sort w podręczniku perlfunc(1).

       Typeglob i uchwyty plików

       Perl posługuje się wewnętrznym typem zwanym typeglob. Przechowuje w nim
       wszystkie zapisy tablicy symboli. Przedrostkiem typu typeglob jest *,
       gdyż reprezentuje on wszystkie typy. Był on zalecanym sposobem
       przekazywania tablic i tablic asocjacyjnych przez odwołanie do funkcji,
       ale obecnie istnieją prawdziwe odwołania, więc jest to rzadko
       potrzebne.

       Podstawowym zastosowaniem typeglob we współczesnym Perlu jest tworzenie
       synonimów tablicy symboli. To przypisanie:

           *cos = *inne;

       robi $cos synonimem (aliasem) dla $inne, @cos jest aliasem dla @inne,
       %cos aliasem dla %inne, &cos aliasem dla &inne, itd. Dużo bezpieczniej
       jest użyć odwołania (wskazania).  To:

           local *Tutaj::niebieski = \$Tam::zielony;

       tymczasowo czyni $Tutaj::niebieski aliasem dla $Tam::zielony, ale nie
       robi @Tutaj::niebieski aliasem dla @Tam::zielony, czy %Tutaj::niebieski
       aliasem dla %Tam::zielony, itd.  W sekcji Symbol Tables podręcznika
       perlmod(1) znajdziesz więcej takich przykładów. Mimo, że może to
       wyglądać dziwnie, jest to podstawą całego systemu importu/exportu
       modułów.

       Innym zastosowaniem typeglob jest przesyłanie uchwytów plików do
       funkcji lub tworzenie nowych uchwytów. Jeżeli potrzebujesz posłużyć się
       typeglob, by zachować uchwyt pliku, zrób to tak:

           $fh = *STDOUT;

       albo może jako prawdziwe odwołanie, jak to:

           $fh = \*STDOUT;

       W podręczniku perlsub(1) znajdziesz przykłady zastosowania typeglob
       jako pośrednich uchwytów plików w funkcjach.

       Typeglob są również sposobem na tworzenie lokalnych uchwytów plików
       przy użyciu operatora local(). Istnieją wówczas aż do wyjścia z ich
       bloku, ale mogą być przesłane powtórnie.  Na przykład:

           sub newopen {
               my $path = shift;
               local *FH;  # nie my!
               open   (FH, $path)          or  return undef;
               return *FH;
           }
           $fh = newopen('/etc/passwd');

       Obecnie, gdy dysponujemy notacją *foo{COŚ}, typeglob nie są tak często
       używane do manipulowania uchwytami plików, chociaż wciąż są konieczne
       do przesłania całkiem nowego uchwytu pliku czy katalogu do funkcji czy
       z funkcji.  Wynika to stąd, że *UCHWYT{IO} działa tylko jeśli UCHWYT
       był już użyty jako uchwyt. Inaczej mówiąc, do tworzenia nowych wpisów w
       tablicy symboli może posłużyć *FH, ale nie *foo{COŚ}.

       Inną metodą tworzenia anonimowych uchwytów plików jest wykorzystanie
       modułu IO::Handle.  Zaletą tych modułów jest nieukrywanie różnych typów
       tej samej nazwy podczas local(). Na końcu opisu open() w podręczniku
       perlfunc(1) zamieszczono odpowiedni przykład.

       Dalsze rozważania na temat typeglob i składni *foo{THING} znajdziesz w
       podręcznikach perlref(1) i perlsub(1), a także w sekcji Symbol Tables
       podręcznika perlmod(1).