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

NAZWA

       perlsyn - Składnia perla

OPIS

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

       Skrypt perla składa się z sekwencji deklaracji i instrukcji. Jedynymi rzeczami, które
       muszą być zadeklarowane w perlu, to formatki raportowe i procedury. Więcej informacji o
       tych deklaracji znajdziesz w sekcjach poniżej. Wszystkie niezainicjalizowane, stworzone
       przez użytkownika obiekty, uznawane są za posiadające początkową wartość null lub 0,
       dopóki nie zostaną zdefiniowane w jakiejś jawnej operacji, jak np. przypisanie. (Choć
       jeśli chcesz, możesz dostawać ostrzeżenia o używaniu wartości niezdefiniowanych.)
       Sekwencja instrukcji jest wykonywana tylko jednokrotnie, w przeciwieństwie do skryptów
       sed(1) czy awk(1), gdzie sekwencja taka jest wykonywana dla każdej linii wejściowej.
       Oznacza to, że musisz jawnie przetwarzać w pętli linie swojego pliku wejściowego (lub
       plików), oznacza to też, że masz dużo większą kontrolę nad tym, którymi plikami i liniami
       się zajmujesz.  (Właściwie to kłamię--można zrobić niejawną pętlę za pomocą przełącznika
       -n lub -p. Nie jest to po prostu domyślne i zarazem obowiązkowe jak w sed(1) czy awk(1).)

       Deklaracje

       Perl jest w ogólności językiem wolnej postaci (free-form). (Jedynym wyjątkiem są
       deklarację formatek--z oczywistych przyczyn.) Komentarze są rozpoczynane znakiem "#" i
       ciągną się do końca linii.  Jeśli spróbujesz użyć komentarzy /* */ w stylu C, to zostaną
       one zinterpretowane albo jako dzielenie, albo jako porównywanie wzorca. Z kolei komentarz
       // z C++ wygląda dokładnie jak puste wyrażenie regularne.  Nie kombinuj więc z tymi
       konstrukcjami.

       Deklaracja może być wstawiona gdziekolwiek, gdzie można wstawić instrukcję, lecz nie ma
       wpływu na wykonywanie podstawowej sekwencji instrukcji--deklaracje mają znaczenie tylko
       podczas kompilacji.  Zazwyczaj wszystkie deklaracje wstawiane są na początku lub na końcu
       skryptu. Jeśli jednak używasz zmiennych prywatnych zawężonych leksykalnie, utworzonych
       przez my(), będziesz musiał się upewnić, czy twoja definicja formatki lub procedury,
       używającej tych deklaracji leży wewnątrz tego samego zakresu.

       Deklarowanie procedury zezwala na używanie jej nazwy tak, jakby była operatorem listowym,
       licząc od tego miejsca, aż do końca programu. Możesz zadeklarować procedurę bez jej
       definiowania, pisząc sub name, więc:

           sub myname;
           $me = myname $0             or die "can't get myname";

       Zauważ, że działa to jak operator listowy, a nie jak jednoargumentowy; uważaj więc i
       używaj or zamiast ⎪⎪. Jednak jeśli zadeklarowałbyś procedurę jako sub myname ($), to
       myname funkcjonowałoby jak operator jednoargumentowy, więc działałyby zarówno or jak i ⎪⎪.

       Deklaracje procedur mogą być również ładowane instrukcją require, lub jednocześnie
       ładowane jak i importowane do przestrzeni nazw dzięki instrukcji use. Dla szczegółów
       polecam podręcznik perlmod(1).

       Sekwencja instrukcji może zawierać deklaracje zmiennych zawężonych leksykalnie, lecz poza
       deklarowaniem nazwy zmiennej, deklaracja działa jak zwykła instrukcja i jest wykonywana w
       sekwencji instrukcji jak zwyczajna instrukcja. Znaczy to, że ma ona zarówno skutki podczas
       kompilacji, jak w czasie działania.

       Instrukcje proste

       Jedynym rodzajem instrukcji prostej jest wyrażenie, analizowane dla swoich efektów
       ubocznych. Każda instrukcja prosta musi się kończyć średnikiem, chyba że jest ostatnią
       instrukcją bloku, wtedy średnik nie jest obowiązujący. (Jednak wciąż jest zalecany jeśli
       blok zajmuje więcej niż jedną linię, gdyż możliwe że dodasz jeszcze kolejne linie.)
       Zauważ, że istnieją operatory takie, jak eval {} i do {}, które wyglądają jak instrukcje
       złożone, lecz nimi nie są i wymagają jawnego zakończenia jeśli są użyte jako ostatni
       element instrukcji.

       Za każdą prostą instrukcją, tuż przed średnikiem (lub końcem bloku) może znajdować się
       POJEDYNCZY modyfikator. Dopuszczalne modyfikatory to:

           if WYRAŻ
           unless WYRAŻ
           while WYRAŻ
           until WYRAŻ
           foreach WYRAŻ

       Modyfikatory if i unless mają semantykę zgodną z oczekiwaniami (jeżeli i chyba że).
       Modyfikator foreach jest iteratorem: dla każdej wartości w WYRAŻ przypisuje jej nazwę
       zastępczą $_ i wykonuje instrukcję. Modyfikatory while i until również mają typową
       semantykę pętli while (warunek jest analizowany najpierw). Wyjątkiem jest poprzedzenie
       tych modyfikatorów konstrukcją do-BLOK - wówczas blok jest wykonywany raz przed
       sprawdzeniem warunku.  Dzięki temu możesz tworzyć pętle w rodzaju:

           do {
               $line = <STDIN>;
               ...
           } until $line  eq ".\n";

       Zobacz opis do w podręczniku perlfunc. Zauważ też, że opisane poniżej instrukcje kontroli
       pętli NIE będą działały w tej konstrukcji, gdyż modyfikatory nie pobierają etykiet pętli.
       Przykro mi.  Możesz zawsze umieścić wewnątrz inny blok (dla WnextfR) lub też umieścić
       swoją instrukcję wewnątrz bloku (dla last), aby zrobić coś takiego.  W przypadku next po
       prostu podwój nawiasy:

          do {{
             next if $x == $y;
             # coś tu robi
          }} until $x++ > $z;

       Dla next musisz się bardziej rozpisać:

          LOOP: {
                  do {
                     last if $x = $y**2;
                     # coś tu robi
                  } while $x++ <= $z;
          }

       Instrukcje złożone

       W perlu, sekwencja instrukcji definiująca zakres nazywana jest blokiem.  Czasami
       ograniczeniem bloku stanowi zawierający go plik (w wypadku wymaganego (required) pliku lub
       programu jako całości), a czasami zasięg łańcucha znakowego (w wypadku eval).

       Lecz ogólnie, blok jest ograniczony nawiasami klamrowymi. Taką konstrukcję syntaktyczną
       nazwiemy BLOKIEM.

       Do kontroli przepływu można używać następujących instrukcji złożonych:

           if (WYRAŻ) BLOK
           if (WYRAŻ) BLOK else BLOK
           if (WYRAŻ) BLOK elsif (WYRAŻ) BLOK ... else BLOK
           ETYKIETA while (WYRAż) BLOK
           ETYKIETA while (WYRAŻ) BLOK continue BLOK
           ETYKIETA for (WYRAŻ; WYRAŻ; WYRAŻ) BLOK
           ETYKIETA foreach VAR (LISTA) BLOK
           ETYKIETA BLOK continue BLOK

       Zauważ, że w przeciwieństwie do C i Pacala, są one zdefiniowane w kategoriach BLOKÓW, a
       nie instrukcji. Znaczy to, że nawiasy klamrowe są niezbędne--wiszące instrukcje nie są
       dozwolone. Jeśli chcesz pisać warunki bez nawiasów, to są na to inne sposoby. Następujące
       przykłady robią wszystkie to samo:

           if (!open(FOO)) { die "Can't open $FOO: $!"; }
           die "Can't open $FOO: $!" unless open(FOO);
           open(FOO) or die "Can't open $FOO: $!";     # FOO lub giń!
           open(FOO) ? 'hi mom' : die "Can't open $FOO: $!";
                               # to ostatnie trochę egzotyczne

       Instrukcja if jest nieskomplikowana. Ponieważ BLOKI są zawsze ograniczone nawiasami
       klamrowymi, nigdy nie ma niejednoznaczności co do tego, do którego if przynależy dany
       else.  Jeśli zamiast if używasz unless, sens testu jest odwrócony.

       Instrukcja while wykonuje swój blok tak długo, jak wyrażenie jest prawdziwe (jego
       wartością nie jest łańcuch pusty, 0 czy "0").  ETYKIETA jest opcjonalna, a jeśli jest
       obecna, składa się z identyfikatora, za którym następuje dwukropek. ETYKIETA identyfikuje
       pętlę dla instrukcji kontroli pętli, czyli next, last i redo.  Jeśli pominięto ETYKIETĘ,
       instrukcje kontroli pętli odnoszą się do najbardziej wewnętrznej otaczającej pętli. Może
       to wymagać dynamicznego przeglądania wstecz stosu wywołań w czasie wykonania, aby znaleźć
       odpowiednią ETYKIETĘ.  Takie desperackie zachowania dają zwykle ostrzeżenia przy włączonej
       fladze -w.

       Jeśli istnieje BLOK continue, to jest on zawsze wykonywany tuż przed kolejną analizą
       warunku, podobnie jak trzeci element pętli for w C. Można tego używać do zwiększania
       zmiennej sterującej pętli, nawet gdy pętla jest właśnie kontynuowana instrukcją next
       (która jest z kolei podobna do instrukcji continue z C).

       Kontrola pętli

       Polecenie next jest podobne do instrukcji continue z C; rozpoczyna nową iterację pętli:

           LINE: while (<STDIN>) {
               next LINE if /^#/;      # wykasuj komentarze
               ...
           }

       Polecenie last jest podobne do instrukcji break z C (używanej w pętlach); natychmiastowo
       opuszcza pętlę. Blok continue nie jest wykonywany:

           LINE: while (<STDIN>) {
               last LINE if /^$/;      # zakończ po obsłużeniu nagłówka
               ...
           }

       Polecenie redo restartuje pętlę bez ponownego analizowania warunku.  Blok continue nie
       jest wykonywany. Polecenie to jest zazwyczaj używane w programach, które chcą się
       okłamywać co do tego, co właśnie pobrały z wejścia.

       Na przykład, podczas przetwarzania pliku takiego, jak /etc/termcap.  Jeśli twoje wiersze
       wejściowe mogą się kończyć lewymi ukośnikami, wskazującymi kontynuację, możesz chcieć z
       wyprzedzeniem pobrać następny rekord.

           while (<>) {
               chomp;
               if (s/\\$//) {
                   $_ .= <>;
                   redo unless eof();
               }
               # teraz przetwórz $_
           }

       co w perlu jest skrótem dla wersji napisanej bardziej dosłownie:

           LINE: while (defined($line = <ARGV>)) {
               chomp($line);
               if ($line =~ s/\\$//) {
                   $line .= <ARGV>;
                   redo LINE unless eof(); # nie eof(ARGV)!
               }
               # teraz przetwórz $line
           }

       A tu mamy prosty striptizer komentarzy Pascalowych (uwaga: zakłada brak { lub } w
       łańcuchach).

           LINE: while (<STDIN>) {
               while (s⎪({.*}.*){.*}⎪$1 ⎪) {}
               s⎪{.*}⎪ ⎪;
               if (s⎪{.*⎪ ⎪) {
                   $front = $_;
                   while (<STDIN>) {
                       if (/}/) {      # koniec komentarza?
                           s⎪^⎪$front{⎪;
                           redo LINE;
                       }
                   }
               }
               print;
           }

       Zauważ, że jeśli w powyższym kodzie istniałby blok continue, został by on wywołany nawet
       dla usuniętych wierszy. Blok ten jest często używany do resetowania liczników wierszy czy
       jednokrotnych dopasowań ?wzorców?.

           # zainspirowane przez :1,$g/fred/s//WILMA/
           while (<>) {
              ?(fred)?     && s//WILMA $1 WILMA/;
              ?(barney)?   && s//BETTY $1 BETTY/;
              ?(homer)?    && s//MARGE $1 MARGE/;
           } continue {
              print "$ARGV $.: $_";
              close ARGV   if eof();    # reset $. (nr wiersza)
              reset        if eof();    # reset ?wzorca?
           }

       Jeśli słowo while jest zamieniane słowem until, to sens testu jest odwrócony, lecz warunek
       jest wciąż testowany w pierwszej iteracji.

       Instrukcje sterujące pętli nie współpracują z if ani unless, gdyż nie są one pętlami.
       Możesz jednak podwoić nawiasy by je nimi uczynić.

           if (/wzorzec/) {{
              next if /fred/;
              next if /barney/;
              # coś tu robi
           }}

       Postać while/if BLOCK BLOCK, która była dostępna w Perl 4 nie jest już prawidłowa. Zmień
       wszystkie wystąpienia if BLOCK na if (do BLOCK).

       Pętle for

       Perlowa pętla for w stylu C, działa dokładnie jak odpowiadająca jej pętla while, co
       znaczy, że to:

           for ($i = 1; $i < 10; $i++) {
               ...
           }

       jest tym samym, co to:

           $i = 1;
           while ($i < 10) {
               ...
           } continue {
               $i++;
           }

       (Jest jedna drobna różnica: pierwsza postać wymusza zawężenie leksykalne dla zmiennych
       zadeklarowanych przez my w wyrażeniu inicjalizacji.)

       Poza zwykłymi pętlami po indeksach tablic, for daje wiele innych zastosowań. Oto przykład,
       zapobiegający problemowi, który napotyka się testując jawnie EOF na interaktywnym
       deskryptorze pliku, co powoduje, że program wygląda jakby się zawiesił.

           $on_a_tty = -t STDIN && -t STDOUT;
           sub prompt { print "yes? " if $on_a_tty }
           for ( prompt(); <STDIN>; prompt() ) {
               # zrób coś
           }

       Pętle foreach

       Pętla foreach iteruje poprzez normalną wartość listową i przypisuje zmiennej VAR wartość
       każdego kolejnego elementu listy. Jeśli zmienna jest poprzedzona słowem kluczowym my, to
       jest ona leksykalnie zawężona i widzialna tylko wewnątrz pętli. W przeciwnym wypadku,
       zmienna jest niejawnie lokalna w pętli i, po wyjściu z niej, odzyskuje pierwotną wartość.
       Jeśli zmienna była poprzednio zadeklarowana przez my, to pętla używa tej zmiennej, zamiast
       zmiennej globalnej, lecz wciąż jest ona lokalna w obrębie pętli. (Zauważ, że zmienne o
       zasięgu leksykalnym mogą być przyczyną kłopotów, jeśli wewnątrz pętli masz odwołujące się
       do nich procedury lub deklaracje formatów.)

       Słowo kluczowe foreach jest w rzeczywistości synonimem słowa for, więc foreach możesz
       używać dla czytelności, a for dla skrócenia. (Albo też powłoka Bourne'a jest Ci milsza niż
       csh, więc pisanie for jest naturalniejsze.)  Jeśli VAR jest pominięte, na kolejne wartości
       ustawiane będzie $_.  Jeśli dowolny element LISTY jest lwartością, to możesz łatwo
       modyfikować jego wartość, modyfikując VAR wewnątrz pętli. Jest tak dlatego, że zmienna
       indeksu pętli foreach jest niejawnym synonimem każdego iterowanego elementu.  W
       szczególności możliwa jest zmiana tym sposobem wartości elementów tablicy LISTA (ale nie
       wyrażenia zwracającego LISTĘ).

       Jeśli dowolna część LISTY jest tablicą, to foreach bardzo się zmiesza, jeśli wewnątrz
       pętli dodasz lub usuniesz elementy, na przykład przy pomocy splice. Nie rób więc tego.

       foreach prawdopodobnie nie zrobi tego, czego oczekujesz, jeśli VAR jest zmienną specjalną.
       Tego też nie rób.

       Przykłady:

           for (@ary) { s/foo/bar/ }

           foreach my $elem (@elements) {
               $elem *= 2;
           }

           for $count (10,9,8,7,6,5,4,3,2,1,'BOOM') {
               print $count, "\n"; sleep(1);
           }

           for (1..15) { print "Merry Christmas\n"; }

           foreach $item (split(/:[\\\n:]*/, $ENV{TERMCAP})) {
               print "Item: $item\n";
           }

       Oto, jak programista C mógłby zakodować szczególny algorytm w perlu:

           for (my $i = 0; $i < @ary1; $i++) {
               for (my $j = 0; $j < @ary2; $j++) {
                   if ($ary1[$i] > $ary2[$j]) {
                       last; # nie mogę wyjść do zewnętrznej :-(
                   }
                   $ary1[$i] += $ary2[$j];
               }
               # tu zabiera mnie last
           }

       Podczas gdy programista perla mógłby zrobić to wygodniej:

           OUTER: foreach my $wid (@ary1) {
           INNER:   foreach my $jet (@ary2) {
                       next OUTER if $wid > $jet;
                       $wid += $jet;
                    }
                 }

       Widzisz jakie to proste? Czystsze, bezpieczniejsze i szybsze. Jest czystsze, bo mniej tu
       zamieszania. Jest bezpieczniejsze, bo jeśli między wewnętrzną, a zewnętrzną pętlę zostanie
       później dodany kod, to nie będzie on przypadkiem wykonywany. next jawnie iteruje inną
       pętlę zamiast przerywania wewnętrznej. Jest to szybsze, gdyż perl wywołuje instrukcje
       foreach szybciej niż równoważnik z pętlą for.

       Podstawowe instrukcje BLOKOWE i switch

       BLOK (z etykietą lub bez) jest równoważny pętli, która jest wykonywana jeden raz. Tak więc
       możesz wewnątrz używać instrukcji kontroli pętli by wyjść z bloku lub ponowić jego
       wykonanie.  (Zauważ, że nie jest to prawdą wewnątrz eval{}, sub{} czy, przeciwnie do
       rozpowszchnionych przekonań, bloków do{}, które nie zaliczają się do pętli.) Blok continue
       jest opcjonalny.

       Konstrukcja BLOKU jest szczególnie wygodna do tworzenia struktur wyboru (case).

           SWITCH: {
               if (/^abc/) { $abc = 1; last SWITCH; }
               if (/^def/) { $def = 1; last SWITCH; }
               if (/^xyz/) { $xyz = 1; last SWITCH; }
               $nothing = 1;
           }

       W perlu nie ma oficjalnej instrukcji switch, gdyż istnieje już kilka sposobów na wykonanie
       jej równoważnika. Oprócz, mógłbyś napisać

           SWITCH: {
               $abc = 1, last SWITCH  if /^abc/;
               $def = 1, last SWITCH  if /^def/;
               $xyz = 1, last SWITCH  if /^xyz/;
               $nothing = 1;
           }

       (W rzeczywistości nie jest to tak dziwne jak wygląda. Musisz sobie uświadomić, że możesz
       korzystać z "operatorów" kontroli pętli wewnątrz wyrażeń. Jest to zwyczajny operator
       przecinka z C.)

       lub

           SWITCH: {
               /^abc/ && do { $abc = 1; last SWITCH; };
               /^def/ && do { $def = 1; last SWITCH; };
               /^xyz/ && do { $xyz = 1; last SWITCH; };
               $nothing = 1;
           }

       lub sformatowane w taki sposób, że wygląda bardziej na "poprawną" instrukcję switch:

           SWITCH: {
               /^abc/      && do {
                                   $abc = 1;
                                   last SWITCH;
                              };

               /^def/      && do {
                                   $def = 1;
                                   last SWITCH;
                              };

               /^xyz/      && do {
                                   $xyz = 1;
                                   last SWITCH;
                               };
               $nothing = 1;
           }

       lub

           SWITCH: {
               /^abc/ and $abc = 1, last SWITCH;
               /^def/ and $def = 1, last SWITCH;
               /^xyz/ and $xyz = 1, last SWITCH;
               $nothing = 1;
           }

       lub nawet straszliwe

           if (/^abc/)
               { $abc = 1 }
           elsif (/^def/)
               { $def = 1 }
           elsif (/^xyz/)
               { $xyz = 1 }
           else
               { $nothing = 1 }

       Popularnym idiomem instrukcji switch jest wykorzystanie tworzonego przez foreach synonimu.
       Uzyskane tymczasowe przypisanie do zmiennej $_ umożliwia wygodne dopasowywanie:

           SWITCH: for ($where) {
                       /In Card Names/     && do { push @flags, '-e'; last; };
                       /Anywhere/          && do { push @flags, '-h'; last; };
                       /In Rulings/        && do {                    last; };
                       die "unknown value for form variable where: `$where'";
                   }

       Innym interesującym podejściem do instrukcji switch jest rozplanowanie bloku do tak, by
       zwracał właściwą wartość:

           $amode = do {
               if     ($flag & O_RDONLY) { "r" }
               elsif  ($flag & O_WRONLY) { ($flag & O_APPEND) ? "a" : "w" }
               elsif  ($flag & O_RDWR)   {
                   if ($flag & O_CREAT)  { "w+" }
                   else                  { ($flag & O_APPEND) ? "a+" : "r+" }
               }
           };

       lub też

               print do {
                   ($flags & O_WRONLY) ? "write-only"          :
                   ($flags & O_RDWR)   ? "read-write"          :
                                         "read-only";
               };

       albo, jeśli jesteś pewien, że wszystkie klauzule && są prawdziwe, możesz posłużyć się
       czymś podobnym, co "przełącza" w zależności od wartości zmiennej środowiska
       HTTP_USER_AGENT.

           #!/usr/bin/perl
           # dobierz plik ze stroną żargonu według przeglądarki
           $dir = 'http://www.wins.uva.nl/~mes/jargon';
           for ($ENV{HTTP_USER_AGENT}) {
               $page  =    /Mac/            && 'm/Macintrash.html'
                        ⎪⎪ /Win(dows )?NT/  && 'e/evilandrude.html'
                        ⎪⎪ /Win⎪MSIE⎪WebTV/ && 'm/MicroslothWindows.html'
                        ⎪⎪ /Linux/          && 'l/Linux.html'
                        ⎪⎪ /HP-UX/          && 'h/HP-SUX.html'
                        ⎪⎪ /SunOS/          && 's/ScumOS.html'
                        ⎪⎪                     'a/AppendixB.html';
           }
           print "Location: $dir/$page\015\012\015\012";

       Ten rodzaj instrukcji switch działa tylko, gdy wiesz, że klauzule && będą prawdziwe. Jeśli
       nie, to powinien być użyty poprzedni przykład z ?:.

       Możesz także rozważyć napisanie hasza (tablicy asocjacyjnej) zamiast syntezowania
       instrukcji switch.

       Goto

       Perl obsługuje instrukcję goto. ETYKIETA pętli nie jest w rzeczywistości prawidłowym celem
       goto; jest tylko nazwą pętli.  Istnieją trzy postacie: goto-ETYKIETA, goto-WYRAŻ i
       goto-&NAZWA.

       Postać goto-ETYKIETA szuka instrukcji oznaczonej ETYKIETĄ i kontynuuje wykonywanie w tym
       miejscu. Nie może być używana do wchodzenia do wnętrza konstrukcji, które wymagają
       inicjalizacji, takich jak procedury lub pętle foreach. Nie może też być używana do
       wchodzenia do konstrukcji, które są w jakiś sposób optymalizowane. Może być używane do
       wchodzenia prawie we wszystkie inne miejsca w zakresie dynamicznym, łącznie z wychodzeniem
       z procedur, lecz zwykle lepiej jest użyć konstrukcji takiej jak last lub die. Autor Perla
       nigdy nie czuł potrzeby używania tej postaci goto (w Perlu--C to inna sprawa).

       Postać goto-WYRAŻ oczekuje nazwy etykiety, której zakres zostanie rozwiązany dynamicznie.
       Umożliwia to stosowanie wyliczanych goto jak w FORTRANie, lecz nie jest zbyt zalecane
       jeśli optymalizujesz z uwagi na konserwację programu:

           goto ("FOO", "BAR", "GLARCH")[$i];

       Postać goto-&NAZWA jest bardzo magiczna i podstawia wywołanie do nazwanej procedury za
       bieżącą procedurę. Jest to używane przez procedury AUTOLOAD(), które chcą ładować inne
       procedury, a potem udawać, że inna procedura została wywołana jako pierwsza (poza tym, że
       wszelkie modyfikacje @_ w bieżącej procedurrze są przenoszone do tej innej procedury.) Po
       takim goto, nawet caller() nie będzie w stanie powiedzieć, że ta procedura została
       wywołana pierwsza.

       W większości tego typu przypadków, zazwyczaj dużo, dużo lepszym pomysłem jest używanie
       strukturalnych mechanizmów kontroli przepływu next, last lub redo, zamiast zwracać się ku
       goto.  Dla niektórych zastosowań, para eval{} i die(), służąca do przetwarzania wyjątków
       może być też rozsądnym wyjściem.

       POD: Osadzona dokumentacja

       Perl posiada mechanizm łączenia dokumentacji z kodem źródłowym.  Podczas oczekiwania
       początku nowej instrukcji, jeśli kompilator natrafi na linię, rozpoczynającą się od znaku
       równości i słowa, jak

           =head1 Here There Be Pods!

       To ten tekst, oraz reszta napisów, aż do linii, rozpoczynającej się od =cut włącznie
       zostaną zignorowane. Format tekstu wtrąconego jest opisany w podręczniku perlpod(1).

       Umożliwia ci to łączenie kodu źródłowego i dokumentacji, jak w

           =item snazzle($)

           Funkcja snazzle() będzie zachowywać się w najbardziej spektakularny
           sposób, jaki możesz sobie wyobrazić, prześcigając nawet cyber
           pirotechnikę.

           =cut powrót do kompilatora, fora z tego pod-fora!

           sub snazzle($) {
               my $thingie = shift;
               .........
           }

       Zauważ, że translatory pod powinny patrzeć tylko na akapity, rozpoczynające się od
       dyrektywy pod (ułatwia to przetwarzanie), podczas gdy kompilator wie, że ma szukać
       sekwencji specjalnych pod nawet w środku akapitu. Znaczy to, że następujący tajny tekst
       będzie ignorowany zarówno przez kompilator, jak i przez translatory.

           $a=3;
           =tajne rzeczy
            warn "Ani POD ani KOD!?"
           =cut powrot
           print "got $a\n";

       Prawdopodobnie nie powinieneś opierać się na warn(), "wypodowanym" na zawsze. Nie
       wszystkie translatory zachowują się w tym momencie dobrze i być może kompilator stanie się
       wybredniejszy.

       Dyrektyw pod można też używać do szybkiego wykomentowania sekcji kodu.

       Plain Old Comments (Nie!)

       Podobnie jak preprocesor C, perl może przetwarzać dyrektywy liniowe. Przy ich użyciu,
       można kontrolować perlowe pojęcie nazw plików i numerów linii w komunikatach o
       błędach/ostrzeżeniach (szczególnie dla łańcuchów, które są przetwarzane z eval()).
       Składnia tego mechanizmu jest taka sama dla jak dla większości preprocesorów C: dopasowuje
       wyrażenie regularne /^#\s*line\s+(\d+)\s*(?:\s"([^"]*)")?/ do $1, będącego numerem linii i
       $2, będącego opcjonalną nazwą pliku (podaną w cudzysłowach).

       Oto niektóre przykłady, które możesz sprawdzić w swojej powłoce:

           % perl
           # line 200 "bzzzt"
           # znak `#' w poprzedniej linii musi być pierwszym znakiem linii
           die 'foo';
           __END__
           foo at bzzzt line 201.

           % perl
           # line 200 "bzzzt"
           eval qq[\n#line 2001 ""\ndie 'foo']; print $@;
           __END__
           foo at - line 2001.

           % perl
           eval qq[\n#line 200 "foo bar"\ndie 'foo']; print $@;
           __END__
           foo at foo bar line 200.

           % perl
           # line 345 "goop"
           eval "\n#line " . __LINE__ . ' "' . __FILE__ ."\"\ndie 'foo'";
           print $@;
           __END__
           foo at goop line 345.

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 perlsyn

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