Provided by: manpages-pl_20060617-3_all bug

NAZWA

       perlop - operatory perla i priorytety

STRESZCZENIE

       Operatory perla maj nastpujce zwizki i priorytety, wymienione od
       najwyszych do najniszych. Zauwa, e wszystkie operatory poyczone z C
       zachowuj tamtejsze zwizki, cho te konwencje s troch skopane.  (Ulatwia
       to nauk perla programistom C.) Poza paroma wyjtkami, wszystkie one
       operuj na wartociach skalarnych, nie tablicowych.

           lewe        wyraenia i lewostronne operatory list
           lewe        ->
           niezwizane ++ --
           prawe       **
           prawe       ! ~ \ and jednoargumentowy + and -
           lewe        =~ !~
           lewe        * / % x
           lewe        + - .
           lewe        << >>
           niezwizane nazwane operatory jednoargumentowe
           niezwizane < > <= >= lt gt le ge
           niezwizane == != <=> eq ne cmp
           lewe        &
           lewe        | ^
           lewe        &&
           lewe        ||
           niezwizane ..  ...
           prawe       ?:
           prawe       = += -= *= etc.
           lewe        , =>
           niezwizane prawostronne operatory list
           prawe       not
           lewe        and
           lewe        or xor

       W nastpujcych sekcjach, operatory te s opisane w kolejnoci
       priorytetowej.

OPIS

       Wyraenia i lewostronne operatory list

       Wyraenie ma w perlu najwyszy priorytet. S to zmienne, cytaty, operatory
       w rodzaju cytatow, dowolne wyraenie w nawiasach, i dowolna funkcja,
       ktorej argumenty s umieszczone w nawiasach. W rzeczywistoci, w perlu
       nie ma tak naprawd funkcji w ogolnym sensie, s tylko operatory listowe
       i operatory jednoargumentowe, zachowujce si jak funkcje, bo ustawiasz
       wokol nich nawiasy. S one opisane w podrczniku perlfunc(1).

       Jeli dowolny operator listowy (print() itp.), lub dowolny operator
       jednoargumentowy (chdir()) ma za sob lewy nawias, to operator i
       argumenty z nawiasow s brane w najwyszym priorytecie, tak jak przy
       normalnym wywolaniu funkcji.

       Gdy nawiasy nie s podane, priorytet operatorow listowych w rodzaju
       print, sort, lub chmod jest albo bardzo wysoki, albo bardzo niski,
       zalenie od tego czy patrzysz na lew stron, czy na praw stron operatora.
       Na przyklad w

           @ary = (1, 3, sort 4, 2);
           print @ary;         # drukuje 1324

       przecinki po prawej stronie sort-a s analizowane przed sortowaniem,
       lecz przecinki po lewej s analizowane poniej. Innymi slowy, operatory
       listowe poeraj wszystkie argumenty, ktore za nimi nastpuj, a potem
       zachowuj si jak proste wyraenie, szanujce wyraenie poprzedzajce.
       Zauwa, e musisz by ostrony z nawiasami:

           # Wykonuj exit przed drukowaniem:
           print($foo, exit);  # raczej nie to, czego chcesz
           print $foo, exit;   # ani to

           # Te drukuj przed wykonaniem exit
           (print $foo), exit; # To jest to czego chcesz
           print($foo), exit;  # to te
           print ($foo), exit; # nawet to

       Zauwa te, e

           print ($foo & 255) + 1, "\n";

       Prawdopodobnie nie robi tego, co oczekujesz. Zobacz sekcj o nazwanych
       operatorach jednoargumentowych.

       Ponadto, jako wyraenia przetwarzane s te konstrukcje do {} i eval {}, a
       take wywolania podprocedur i metod, oraz anonimowe konstruktory [] i
       {}.

       Zobacz te sekcj o operatorach cytowania, a take sekcj o operatorach
       I/O.

       Operator strza/l/lki

       Podobnie jak w C i C++, "->" jest operatorem dereferencji.  Jeli prawa
       strona to element [...] lub {...}, to lewa strona musi by tward, lub
       symboliczn referencj do tablicy, lub tablicy asocjacyjnej (lub miejsca,
       ktore jest w stanie przechowywa tward referencj, jeli jest to lwarto
       (przypisywalna)). Zobacz stron perlref(1).

       W przeciwnym wypadku, prawa strona jest nazw metody, lub prost zmienn
       skalarn, zawierajc nazw metody, a lewa strona musi by albo obiektem
       (poblogoslawion przez bless referencj), lub nazw klasy (tj. nazw
       pakietu).  Zobacz stron perlobj(1).

       Auto-inkrementacja i Auto-dekrementacja

       "++" i "--" dzialaj jak w C. To znaczy, jeli s umieszczone przed
       zmienn, to inkrementuj lub dekrementuj zmienn przed zwroceniem wartoci,
       a jeli s umieszczone za zmienn, to powoduj inkrementacj lub
       dekrementacj po zwroceniu wartoci.

       Operator auto-inkrementacji ma wbudowanych par dodatkowych rzeczy. Jeli
       inkrementujesz zmienn, ktora jest numeryczna, lub ktora byla
       kiedykolwiek uyta w kontekcie numerycznym, to uzyskasz normaln
       inkrementacj. Jednak jeli zmienna byla uywana tylko w kontekstach
       lacuchowych, a jej warto nie jest nullem i odpowiada wzorcowi /^[a-zA-
       Z]*[0-9]*$/, to inkrementacja jest dokonywana jak na lacuchu, zachowujc
       kady znak w zakresie, z przeniesieniem:

           print ++($foo = '99');      # drukuje '100'
           print ++($foo = 'a0');      # drukuje 'a1'
           print ++($foo = 'Az');      # drukuje 'Ba'
           print ++($foo = 'zz');      # drukuje 'aaa'

       Operator autodekrementacji nie ma tych wlaciwoci.

       Potga

       Binarny "**" jest operatorem potgowania. Zauwa, e lczy mocniej ni
       jednoargumentowy minus, wic -2**4 to -(2**4), a nie (-2)**4.  (Jest to
       zaimplementowane przy uyciu funkcji pow(3) z C, ktora w rzeczywistoci
       dziala na liczbach typu podwojnej precyzji.)

       Symboliczne operatory jednoargumentowe

       Jednoargumentowy "!"  wykonuje negacj logiczn, czyli "not".  Zobacz te
       not dla wersji o niszym priorytecie.

       Jednoargumentowy "-" dokonuje arytmetycznej negacji na numerycznym
       operandzie. Jeli operand jest identyfikatorem, zwracany jest lacuch
       skladajcy si ze znaku minus i z identyfikatora.  W przeciwnym wypadku,
       jeli lacuch rozpoczyna si znakiem plus lub minus, zwracany jest lacuch
       z przeciwnym znakiem. Jednym z efektow tego dzialania jest to, e
       -bareword jest rownowane "-bareword".

       Jednoargumentowy "~" dokonuje negacji bitowej.  (Zobacz te sekcj o
       arytmetyce calkowitej.)

       Jednoargumentowy "+" nie daje adnego efektu, nawet na lacuchach. Jest
       przydatny do rozdzielania nazwy funkcji od otoczonego nawiasami
       wyraenia, ktore w przeciwnym wypadku byloby interpretowane jako
       calkowita lista argumentow funkcji. (Zobacz przyklady w sekcji o
       wyraeniach i lewostronnych operatorach listowych.)

       Jednoargumentowy "\" tworzy referencj do tego, co po nim nastpuje.
       Zobacz podrcznik perlref(1).  Nie myl tego zachowania z zachowaniem w
       lacuchu odwrotnego ukonika, cho obie postacie maj t sam wlaciwo
       chronienia nastpnej rzeczy od interpretacji.

       Operatory /l/lczenia

       Binarny "=~" lczy wyraenie skalarne z obslug wyraenia regularnego.
       Pewne operacje domylnie szukaj lub zmieniaj lacuch $_.  Operator ten
       powoduje, e taka operacja dziala na innym lacuchu. Prawy argument jest
       wzorcem przeszukiwania, podstawienia lub translacji. Lewy argument jest
       przeszukiwanym lacuchem, zamiast domylnego $_.  Warto zwracana okrela
       sukces operacji. (Jeli prawy argument jest raczej wyraeniem ni wzorcem
       przeszukiwania, podstawiania lub translacji, to jest interpretowany
       jako wzorzec przeszukiwania czasu dzialania. Moe to by mniej efektywne
       ni jawne szukanie, gdy wzorzec musi by za kadym razem kompilowany.

       [Przyp. tlum: Na przyklad "$lancuch="bla"; $lancuch=~s/l/q/; print
       $lancuch" da w wyniku lacuch "bqa".]

       Binarny "!~" jest podobny do "=~" lecz warto zwracana jest logicznie
       negowana.

       Operatory mnoenia

       Binarny "*" mnoy dwie liczby.

       Binarny "/" dzieli dwie liczby.

       Binarny "%" oblicza reszt (modulo) z dwoch liczb. Z calkowitymi
       operandami $a i $b: jeli $b jest dodatnie, to $a % $b to $a minus
       najwiksza wielokrotno $b, ktora nie jest wiksza od $a.  Jeli $b jest
       ujemne, to $a % $b to $a minus najmniejsza wielokrotno $b, ktora nie
       jest mniejsza ni $a (np. wynik bdzie mniejszy lub rowny od zera).

       Binarny "x" jest operatorem powtorzenia.  W kontekcie skalarnym, zwraca
       lacuch skladajcy si z lewego operanda, powtorzonego tyle razy, ile
       podano w prawym. W kontekcie listowym, jeli lewy operand jest list w
       nawiasach, powtarzana jest lista.

           print '-' x 80;             # wydrukuj wiersz kresek

           print "\t" x ($tab/8), ' ' x ($tab%8);      # tabuluj poprzez

           @ones = (1) x 80;           # lista 80 jedynek
           @ones = (5) x @ones;        # ustaw wszystkie elementy na 5

       Operatory dodawania

       Binarny "+" zwraca sum dwoch liczb.

       Binarny "-" zwraca ronic dwoch liczb.

       Binarny "." lczy (konkatenuje) lacuchy.

       Operatory przesuwania

       Binanry "<<" zwraca warto swojego lewego argumentu, przesunitego w lewo
       o ilo bitow, podan w prawym argumencie. Argumenty powinny by liczbami
       calkowitymi. (Zobacz te sekcj o arytmetyce calkowitej.)

       Binarny ">>" zwraca warto swojego lewego argumentu, przesunitego w
       prawo o ilo bitow, podan w prawym argumencie. Argumenty powinny by
       liczbami calkowitymi.

       Nazwane operatory jednoargumentowe

       Rone nazwane operatory jednoargumentowe s traktowane jak
       jednoargumentowe funkcje, z opcjonalnymi nawiasami. S to m.in testy
       plikowe, itp. Zobacz podrcznik perlfunc(1).

       Jeli za dowolnym operatorem listowym (print() itp.), lub operatorem
       jednoargumentowym (chdir() itp.) nastpuje lewy nawias, to operator i
       argumenty w nawiasach s brane z najwyszym priorytetem, tak jak przy
       wywolaniu funkcji. Przyklady:

           chdir $foo    || die;       # (chdir $foo) || die
           chdir($foo)   || die;       # (chdir $foo) || die
           chdir ($foo)  || die;       # (chdir $foo) || die
           chdir +($foo) || die;       # (chdir $foo) || die

       lecz poniewa * ma wyszy priorytet ni ||:

           chdir $foo * 20;    # chdir ($foo * 20)
           chdir($foo) * 20;   # (chdir $foo) * 20
           chdir ($foo) * 20;  # (chdir $foo) * 20
           chdir +($foo) * 20; # chdir ($foo * 20)

           rand 10 * 20;       # rand (10 * 20)
           rand(10) * 20;      # (rand 10) * 20
           rand (10) * 20;     # (rand 10) * 20
           rand +(10) * 20;    # rand (10 * 20)

       Zobacz te sekcj o wyraeniach i lewostronnych operatorach listowych.

       Operatory relacji

       Binarny "<" zwraca prawd, jeli lewy argument jest numerycznie mniejszy
       ni prawy.

       Binarny ">" zwraca prawd, jeli lewy argument jest numerycznie wikszy ni
       prawy.

       Binarny "<=" zwraca prawd, jeli lewy argument jest numerycznie mniejszy
       lub rowny prawemu.

       Binarny ">=" zwraca prawd, jeli lewy argument jest numerycznie wikszy
       lub rowny prawemu.

       Binarny "lt" zwraca prawd, jeli lewy argument jest lacuchowo mniejszy
       od prawego.

       Binarny "gt" zwraca prawd, jeli lewy argument jest lacuchowo wikszy od
       prawego.

       Binarny "le" zwraca prawd, jeli lewy argument jest lacuchowo mniejszy
       lub rowny prawemu.

       Binarny "ge" zwraca prawd, jeli lewy argument jest lacuchowo wikszy lub
       rowny prawemu.

       Operatory r'o'ownoci

       Binarny "==" zwraca prawd, jeli lewy argument jest numerycznie rowny
       prawemu.

       Binarny "!=" zwraca prawd, jeli lewy argument nie jest numerycznie
       rowny prawemu.

       Binarny "<=>" zwraca -1, 0, lub 1, zalenie od tego czy lewy argument
       jest numerycznie mniejszy, rowny, lub wikszy od prawego.

       Binarny "eq" zwraca prawd, jeli lewy argument jest lacuchowo rowny
       prawemu.

       Binarny "ne" zwraca prawd, jeli lewy argument nie jest lacuchowo rowny
       prawemu.

       Binarny "cmp" zwraca -1, 0, lub 1, zalenie od tego, czy lewy argument
       jest lacuchowo mniejszy, rowny, lub wikszy od prawego.

       "lt", "le", "ge", "gt" i "cmp" mog uywa kolejnoci sortowania, okrelonej
       przez biece locale (gdy uyte jest use locale). Zobacz podrcznik
       perllocale(1).

       Bitowy And

       Binarny "&" zwraca jego operatory, polczone bitowo operacj logiczn AND.
       (Zobacz te sekcj o arytmetyce calkowitej.)

       Bitowy Or i Xor (eXclusive Or)

       Binarny "|" zwraca swoje operatory, polczone bitowo operacj logiczn OR.
       (Zobacz te sekcj o arytmetyce calkowitej).

       Binarny "^" zwraca swoje operatory, polczone bitowo operacj XOR.
       (Zobacz te sekcj o arytmetyce calkowitej.)

       Logiczny And w stylu C

       Binarny "&&" dokonuje logicznej operacji AND. Jeli lewy operand jest
       falszywy (false), to prawy nie jest nawet analizowany. Kontekst
       skalarny, lub listowy propaguje do prawego operatora, jeli jest on
       analizowany.

       Logiczny Or w stylu C

       Binarny "||" dokonuje logicznej operacji OR. To znaczy, e jeli lewy
       operand jest prawdziwy (true), to prawy nie jest nawet analizowany.
       Kontekst skalarny, lub listowy propaguje do prawego operatora, jeli
       jest on analizowany.

       Operatory || i && roni si od C tym, e zwracaj ostatni analizowan warto
       zamiast 0 czy 1. Tak wic przenonym sposobem znalezienia katalogu
       domowego (zakladajc, e nie jest "0"), moe by:

           $home = $ENV{'HOME'} || $ENV{'LOGDIR'} ||
               (getpwuid($<))[7] || die "You're homeless!\n";

       Jako czytelniejsze alternatywy && i ||, perl udostpnia operatory "and"
       i "or" (patrz niej).  Zachowanie jest identyczne. Jednak ich priorytet
       jest niszy, wic moesz ich bezpiecznie uywa po operatorze listowym, bez
       koniecznoci uywania nawiasow:

           unlink "alpha", "beta", "gamma"
                   or gripe(), next LINE;

       Z uyciem operatorow w stylu C, trzeba by bylo to zapisa jako:

           unlink("alpha", "beta", "gamma")
                   || (gripe(), next LINE);

       Operator zakresu

       Binarny ".." jest operatorem zakresu, ktory jest w rzeczywistoci dwoma
       innymi operatorami, zalenymi od kontekstu. W kontekcie listowym, zwraca
       tablic wartoci, liczon (po jednym) od wartoci lewej do prawej.  Jest to
       przydatne do zapisywania ptli for (1..10) i robienia operacji wycinania
       (slice) na tablicach.  Bd wiadom, e w biecej implementacji tworzona
       jest tymczasowa tablica, wic potrzeba na to troch pamici, jeli
       zapiszesz co takiego:

           for (1 .. 1_000_000) {
               # kod
           }

       W kontekcie skalarnym, ".." zwraca warto logiczn. Operator jest
       dwustanowy, jak flip-flop i emuluje operator zakresu liniowego
       (przecinek) z sed(1), awk(1) i ronych edytorow. Kady operator ".."
       obsluguje swoj wlasny stan logiczny. Jest on falszywy tak dlugo, jak
       dlugo lewy operand jest falszywy. Gdy lewy operand stanie si prawdziwy,
       operator zakresu pozostaje prawdziwy dopoki prawy argument jest prawd,
       PO czym, operator zakresu przyjmuje warto falszu. (Nie staje si
       falszywym do czasu nastpnej jego analizy. Moe testowa prawy operand i
       sta si falszywym w tej samej analizie, kiedy stal si prawdziwym (jak w
       awk(1)), lecz wci bdzie raz zwracal prawd. Jeli nie chcesz by testowal
       prawy operand przed nastpn analiz (jak w sed(1)), uyj trzech kropek
       ("...") zamiast dwoch.) Prawy operand nie jest analizowany podczas gdy
       operator jest w stanie falszu, a lewy operand nie jest analizowany gdy
       operator jest w stanie prawdy. Priorytet jest troch niszy ni || i &&.
       Zwracana warto jest albo lacuchem null dla falszu, lub liczb sekwencyjn
       (zaczynajc si od 1) dla prawdy. Liczba sekwencyjna jest resetowana dla
       kadego napotkanego zakresu. Kocowa liczba sekwencyjna w zakresie ma
       doklejony lacuch "E0(R)", ktory nie ma jednak wplywu na warto
       numeryczn, a za to daje co, czego moesz oczekiwa na kocu. Moesz wylczy
       punkt pocztkowy przez oczekiwanie a liczba sekwencyjna stanie si wiksza
       ni jeden. Jeli ktory z operandow skalarnego ".." jest literalem
       numerycznym, operand jest niejawnie porownywany ze zmienn $., biecym
       numerem linii.  Przyklady

       Jako operator skalarny:

           if (101 .. 200) { print; }  # wydrukuj drug setk linii
           next line if (1 .. /^$/);   # pomi linie naglowka [pocztowego]
           s/^/> / if (/^$/ .. eof()); # Cytuj cialo

       Jako operator listowy:

           for (101 .. 200) { print; } # drukuj 100 razy $_ 100
           @foo = @foo[0 .. $#foo];    # kosztowny no-op
           @foo = @foo[$#foo-4 .. $#foo];      # wytnij ostatnich 5 elementow

       Operator zakresu (w kontekcie listowym) uywa w wypadku gdy operandy s
       lacuchami magicznego algorytmu autoinkrementacji. Moesz powiedzie

           @alphabet = ('A' .. 'Z');

       i uzyska tak wszystkie litery alfabetu, lub

           $hexdigit = (0 .. 9, 'a' .. 'f')[$num & 15];

       by uzyska liczby szesnastkowe, lub

           @z2 = ('01' .. '31');  print $z2[$mday];

       by uzyska daty z pocztkowymi zerami. Jeli ostatnia podana warto nie
       jest w sekwencji, ktor daje magiczna inkrementacja, to sekwencja idzie
       tak daleko, a nastpna warto nie bdzie dlusza ni podana ostatnia warto.

       Operator warunkowy

       "?:" jest operatorem warunkowym, zupelnie jak w C. Dziala podobnie do
       konstrukcji if-then-else. Jeli argument przed ? jest prawdziwy, to
       zwracany jest argument przed :. W przeciwnym wypadku, zwracany jest
       argument po :. Na przyklad:

           printf "Mam %d ps%s.\n", $n,
                   ($n == 1) ? "a" : "y";

       Kontekst skalarny, lub listowy propaguje do 2-giego lub 3-ciego
       argumentu, zalenie od wyboru.

           $a = $ok ? $b : $c;  # we skalar
           @a = $ok ? @b : @c;  # we tablic
           $a = $ok ? @b : @c;  # oops, to tylko licznik!

       Operator moe by przypisany jeli obydwa argumenty -- 2-gi i 3-ci s
       legalnymi lwartociami (co znaczy e mona do nich przypisa):

           ($a_or_b ? $a : $b) = $c;

       Niekoniecznie musi to jednak poprawi czytelno twojego programu.

       Operatory przypisania

       "=" jest zwyklym operatorem przypisania.

       Operator przypisania dziala jak w C. Tzn,

           $a += 2;

       jest rownowane

           $a = $a + 2;

       cho bez powielania efektow ubocznych, ktore moe pociga za sob
       dereferencja lwartoci, tak jak dla tie(). Inne operatory przypisania
       dzialaj podobnie. Rozpoznawane s nastpujce:

           **=    +=    *=    &=    <<=    &&=
                  -=    /=    |=    >>=    ||=
                  .=    %=    ^=
                        x=

       Zauwa, e podczas gdy s one zgrupowane w rodziny, maj jednakowy
       priorytet przypisania.

       W przeciwiestwie do C, operator przypisania daje prawidlow lwarto.
       Modyfikowanie przypisania jest rownowane do robienia przypisania, a
       potem zmieniania przypisanej zmiennej. jest to przydatne do
       modyfikowania kopii czego, np:

           ($tmp = $global) =~ tr [A-Z] [a-z];

       Podobnie,

           ($a += 2) *= 3;

       jest rownowane

           $a += 2;
           $a *= 3;

       Operator przecinka

       Binarny "," jest operatorem przecinka. W kontekcie skalarnym analizuje
       swoj lewy argument, wyrzuca jego warto i nastpnie analizuje prawy
       argument, zwracajc jego warto. Jest to takie samo, jak operator
       przecinka z C.

       W kontekcie listowym, jest to po prostu separator listy i wstawia
       obydwa argumenty do listy.

       Znak => jest czsto synonimem operatora przecinka. Przydatny jest do
       dokumentowania argumentow, ktore s w parach. Od wersji 5.001 wymusza to
       te interpretacj kadego slowa z lewej jako lacucha.

       Operatory listowe (w prawo)

       Po prawej stronie operatora listowego, jest niski priorytet, taki e
       kontroluje on wszystkie znalezione tam elementy, oddzielone
       przecinkami.  Jedyne operatory o niszym priorytecie to operatory
       logiczne "and", "or", i "not", ktore mog by uywane do analizowania
       wywola do operatorow listowych, bez potrzeby dodatkowych nawiasow:

           open HANDLE, "filename"
               or die "Can't open: $!\n";

       Zobacz te dyskusj operatorow listowych w sekcji o wyraeniach i
       operatorach listowych lewostronnych.

       Logiczny Not

       Jednoargumentowy "not" zwraca logiczn negacj prawego argumentu.  Jest
       rownowany "!", lecz ma niszy priorytet.

       Logiczny And

       Binarny "and" zwraca logiczn koniunkcj otaczajcych wyrae. Jest
       rownowany &&, lecz ma niszy priorytet. Znaczy to, e prawe wyraenie jest
       analizowane tylko jeli lewe jest prawdziwe.

       Logiczny or i xor

       Binarny "or" zwraca logiczn dyzjunkcj otaczajcych wyrae. Jest rownowany
       ||, lecz ma niszy priorytet. Znaczy to, e prawe wyraenie jest
       wykonywane tylko jeli lewe jest falszywe.

       Binarny "xor" zwraca XOR otaczajcych wyrae.  Nie moe by oczywicie
       uywany z zaweniem, jak or.

       Operatory C, kt'o'orych brakuje w perlu

       Oto operatory C, ktorych perl nie posiada:

       jednoargumentowy &
               Operator adresu. (Lecz zobacz opis operatora "\".)

       jednoargumentowy *
               Operator dereferencji (wyluskania) adresu. (Perlowe
               przedrostkowe operatory dereferencji to: $, @, %, &.)

       (TYP)   Operator konwersji typow.

       Operatory cytat'o'ow i cytatopodobne

       Podczas gdy normalnie mylimy o cytatach jak o literalnych wartociach, w
       perlu maj one funkcj operatorow, dajc rone wlaciwoci interpolowania i
       porownywania wzorcow.  Perl daje dla tych zachowa tradycyjne znaki
       cytowania, lecz rownie sposob na wybieranie znaku cytowania. W
       nastpujcej tablicy, {} oznacza par ogranicznikow, ktore wybierzesz.
       Ograniczniki nienawiasowe uywaj tego samego znaku na pocztek i koniec,
       ale 4 rodzaje nawiasow mog si zagnieda.

           Zwyczajowy Standardowy Znaczenie    Interpoluje
               ''       q{}       Literal         nie
               ""      qq{}       Literal         tak
               ``      qx{}       Komenda         tak
                       qw{}      Lista slow       nie
               //       m{} Porownanie ze wzorcem tak
                        s{}{}   Podstawienie      tak
                       tr{}{}   Translacja        nie

       Dla konstrukcji, wykonujcych interpolacj, zmienne zaczynajce si od "$"
       lub "@" s interpolowane jako nastpujce sekwencje:

           \t          tab             (HT, TAB)
           \n          nowalinia       (LF, NL)
           \r          return          (CR)
           \f          form feed       (FF)
           \b          backspace       (BS)
           \a          alarm (dzwonek) (BEL)
           \e          escape          (ESC)
           \033        znak osemkowy
           \x1b        znak szesnastkowy
           \c[         znak sterujcy
           \l          zmie nastpny znak na mal liter
           \u          zmie nastpny znak na du liter
           \L          zmie na mal liter a do \E
           \U          zmie na du liter a do \E
           \E          koniec modyfikacji rozmiaru
           \Q          cytuj metaznaki regexp a do \E

       Jeli uywane jest use locale, mapa rozmiarow liter odpowiada lokalnej
       sytuacji. Zobacz podrcznik perllocale(1).

       Wzorce s podstaw do innego poziomu interpretacji -- jako wyraenia
       regularne. Jest to robione jako drugi przebieg, po interpolacji
       zmiennych, tak e wyraenia regularne mog by wlczane do wzorca ze
       zmiennych. Jeli tego nie chcesz, uyj \Q.

       Poza powyszym, nie ma wielokrotnych poziomow interpolacji. W
       rzeczywistoci, w przeciwiestwie do oczekiwa programistow powlokowych,
       odwrotne cudzyslowy nie interpoluj w podwojnych cudzyslowach, a
       pojedyncze otoczone w podwojnych cudzyslowach nie utrudniaj analizy
       zmiennych w nich zawartych.

       Operatory cytatopodobne Regexp

       Oto cytatopodobne operatory, ktore dotycz si dziala zwizanych z
       porownywaniem wzorcow.

       ?WZORZEC?
               Jest to co w rodzaju przeszukiwania /wzorzec/, lecz midzy
               wywolaniami operatora reset(), trafienie jest jednokrotne.
               Jest to przydatna optymalizacja, jeli np. chcesz zobaczy tylko
               pierwsze pojawienie si czego w pliku, lub zbiorze.  Resetowane
               s tylko wzorce ??, lokalne dla biecego pakietu.

               To uycie jest niezalecane i moe by usunite w przyszlych
               wersjach perla.

       m/WZORZEC/gimosx

       /WZORZEC/gimosx
               Przeszukuje wzorzec dla trafienia i w kontekcie skalarnym
               wzraca prawd (1), lub falsz (''). Jeli nie podano adnego
               lacucha poprzez operator =~, lub !~, przeszukiwany jest lacuch
               $_.  (Lacuch podany przez =~ nie musi by lwartoci -- moe by
               wynikiem analizy wyraenia, lecz pamitaj, e =~ wie do mocno.)
               Zobacz te podrcznik perlre(1).  Zobacz podrcznik perllocale(1)
               dla dyskusji o dodatkowych sprawach, zwizanych z uyciem use
               locale.

               Opcje to:

                   g   Porownuj globalnie, na wszystkich pojawieniach
                   i   Porownuj bez zwracania uwagi na wielko liter
                   m   Traktuj lacuch jako wielokrotne linie
                   o   Kompiluj wzorzec tylko raz
                   s   Traktuj lacuch jako pojedyncz lini
                   x   Uyj rozszerzonych wyrae regularnych

               Jeli ogranicznikiem jest "/", to pocztkowe m jest opcjonalne.
               Uywajc m, moesz wykorzysta jako ograniczniki dowoln par
               nialfanumerycznych, niebialospacjowych znakow. Jest to
               przydatne do porownywania unixowych nazw cieek, ktore mog
               zawiera "/".  Zapobiega to LTS (syndrom wskiej wykalaczki).
               Jeli "?"  jest ogranicznikiem, to stosowana jest regula
               trafienia-tylko-raz instrukcji ?WZORZEC?.

               WZORZEC moe zawiera zmienne, ktore bd interpolowane (a wzorzec
               rekompilowany) za kad analiz. (Zauwa, e $) i $| mog nie by
               interpolowane, gdy wygldaj jak testy koca lacucha.)  Jeli
               chcesz, by takie wzorce byly kompilowane tylko raz, dodaj do
               ostatniego ogranicznika znak /o. Zapobiega to kosztownej
               kompilacji czasu dzialania i jest przydatne, gdy warto, z
               ktorej korzystasz nie zmienia si w czasie ycia skryptu. Jednak
               pamitaj, e opcja /o daje obietnic, i nie zmienisz zmiennych ze
               wzorca.  Jeli je zmienisz, perl tego nie zauway.

               Jeli WZORZEC zostanie zanalizowany jako lacuch null, to uyte
               zostanie ostatnie wykonane wyraenie regularne.

               W kontekcie, wymagajcym wartoci listowej, porownanie wzorca
               zwraca list, skladajc si z listy podwyrae, trafionych przez
               nawiasy z wzorca, np.  ($1, $2, $3...).  (Zauwa, e ustawione tu
               s rownie $1 itp. i e roni si to od zachowania perla 4.) Jeli
               porownanie si nie powiedzie, zwracana jest tablica null. Jeli
               porownanie si powiedzie, lecz nie bdzie nawiasow, zwracana
               zostanie warto listowa (1).

               Przyklady:

                   open(TTY, '/dev/tty');
                   <TTY> =~ /^y/i && foo();    # zrob foo, jeli trzeba

                   if (/Version: *([0-9.]*)/) { $version = $1; }

                   next if m#^/usr/spool/uucp#;

                   # grep biedaka
                   $arg = shift;
                   while (<>) {
                       print if /$arg/o;       # kompiluj tylko raz
                   }

                   if (($F1, $F2, $Etc) = ($foo =~ /^(\S+)\s+(\S+)\s*(.*)/))

               Ostatni przyklad dzieli $foo na pierwsze dwa slowa i reszt
               linii.  Przypisuje te trzy pola do $F1, $F2 i $Etc.  Warunek
               jest prawdziwy, jeli przypisane zostaly wartoci ktorejkolwiek
               ze zmiennych, czyli jeli wzorzec zostal trafiony.

               Modyfikator /g okrela globalne porownywanie wzorcow -- tj.
               takie, gdzie trafie jest tyle ile si da w danym lacuchu.
               Zachowanie tego zaley od kontektu -- w listowym zwracana jest
               lista wszystkich podlacuchow, trafionych przez wszystkie
               nawaisy wyraenia regularnego.  Jeli nie bylo nawiasow, zwracana
               jest lista trafionych lacuchow, tak jakby byly nawiasy wokol
               calego wzorca.

               W kontekcie skalarnym, ,//g iteruje poprzez lacuch, zwracajc
               TRUE za kadym trafieniem i FALSE przy braku trafienia.  (Innymi
               slowy, zapamituje ostatni pozycj i restartuje od tego miejsca.
               Moesz znale biec pozycj trafienia przy uyciu funkcji pos();
               zobacz jej opis w podrczniku perlfunc(1).)  Brak trafienia
               normalnie resetuje pozycj przeszukiwania na pocztek lacucha,
               lecz moesz temu zapobiec, dodajc modyfikator "c" (np. m//gc).
               Modyfikowanie lacucha docelowego rownie resetuje pozycj
               przeszukiwania.

               Moesz miesza porownania m//g z m/\G.../g, gdzie \G jest
               zapewnieniem zerowej szerokoci, ktore trafia w dokladnie t sam
               pozycj, gdzie skoczyl ewentualny poprzedni m//g.  Zapewnienie
               \G nie jest obslugiwane bez modyfikatora /g; obecnie bez /g,
               \G, zachowuje si zupelnie jak \A, lecz jest to przypadkowe i
               moe si w przyszloci zmieni.

               Przyklady:

                   # kontekst listowy
                   ($one,$five,$fifteen) = (`uptime` =~ /(\d+\.\d+)/g);

                   # kontekst skalarny
                   $/ = ""; $* = 1;  # $*, niezalecany w nowoczesnych perlach
                   while (defined($paragraph = <>)) {
                       while ($paragraph =~ /[a-z]['")]*[.!?]+['")]*\s/g) {
                           $sentences++;
                       }
                   }
                   print "$sentences\n";

                   # uywanie m//gc z \G
                   $_ = "ppooqppqq";
                   while ($i++ < 2) {
                       print "1: '";
                       print $1 while /(o)/gc; print "', pos=", pos, "\n";
                       print "2: '";
                       print $1 if /\G(q)/gc;  print "', pos=", pos, "\n";
                       print "3: '";
                       print $1 while /(p)/gc; print "', pos=", pos, "\n";
                   }

               Ostatni przyklad powinien da:

                   1: 'oo', pos=4
                   2: 'q', pos=5
                   3: 'pp', pos=7
                   1: '', pos=7
                   2: 'q', pos=8
                   3: '', pos=8

               Przydatnym idiomem dla skanerow w rodzaju lex jest /\G.../gc.
               Moesz tak lczy rone rodzaje wyrae regularnych, majc tak moliwo
               przetwarzania lacucha kawalek po kawalku, dokonujc ronych
               akcji, zalenie od tego, ktore wyraenie zostalo trafione. Kade
               wyraenie probuje trafi tam, gdzie poprzednie zakoczylo.

                $_ = <<'EOL';
                     $url = new URI::URL "http://www/";   die if $url eq "xXx";
                EOL
                LOOP:
                   {
                     print(" digits"),         redo LOOP if /\G\d+\b[,.;]?\s*/gc;
                     print(" lowercase"),      redo LOOP if /\G[a-z]+\b[,.;]?\s*/gc;
                     print(" UPPERCASE"),      redo LOOP if /\G[A-Z]+\b[,.;]?\s*/gc;
                     print(" Capitalized"),    redo LOOP if /\G[A-Z][a-z]+\b[,.;]?\s*/gc;
                     print(" MiXeD"),          redo LOOP if /\G[A-Za-z]+\b[,.;]?\s*/gc;
                     print(" alphanumeric"),   redo LOOP if /\G[A-Za-z0-9]+\b[,.;]?\s*/gc;
                     print(" line-noise"),     redo LOOP if /\G[^A-Za-z0-9]+/gc;
                     print ". That's all!\n";
                   }

               Oto wyjcie (podzielone na kilka linii):

                line-noise lowercase line-noise lowercase UPPERCASE line-noise
                UPPERCASE line-noise lowercase line-noise lowercase line-noise
                lowercase lowercase line-noise lowercase lowercase line-noise
                MiXeD line-noise. That's all!

       q/LACUCH/

       'LACUCH'
               Pojedynczo zacytowany lacuch literalny. Odwrotny ukonik oznacza
               odwrotny ukonik, chyba e znajduje si za nim ogranicznik lub
               inny odwrotny ukonik -- w tym wypadku odwrotny ukonik, lub
               ogranicznik jest interpolowany.

                   $foo = q!I said, "You said, 'She said it.'"!;
                   $bar = q('This is it.');
                   $baz = '\n';                # lacuch dwuznakowy

       qq/LACUCH/

       """"LACUCH""""
               Lacuch w podwojnych cudzyslowach, interpolowany.

                   $_ .= qq
                    (*** The previous line contains the naughty word "$1".\n)
                               if /(tcl|rexx|python)/;      # :-)
                   $baz = "\n";                # lacuch jednoznakowy

       qx/LACUCH/

       `LACUCH`
               Lacuch, ktory jest interpolowany, a nastpnie uruchamainay jako
               komenda systemowa. Zebrane standardowe wyjcie komendy jest
               zwracane. W kontekcie skalarnym, pojawia si jako pojedynczy,
               wieloliniowy lacuch.  W kontekcie listowym, jest rozdzielony na
               list linii (jakkolwiek zdefiniowale linie $/ lub
               $INPUT_RECORD_SEPARATOR).

                   $today = qx{ date };

               Zobacz sekcj o operatorach I/O.

       qw/LACUCH/
               Zwraca list slow, wycignitych z lacucha przy uyciu osadzonych
               bialych spacji, jako ogranicznikow slow. Jest to rownowane

                   split(' ', q/LACUCH/);

               Pewne czsto uywane przyklady:

                   use POSIX qw( setlocale localeconv )
                   @EXPORT = qw( foo bar baz );

               Czstym bldem jest proba rozdzielania slow przecinkiem, lub
               wstwianie do wieloliniowych lacuchow qw komentarzy. W tej
               sytuacji, przelcznik -w daje ostrzeenia jeli lacuch zawiera
               znaki "#".

       s/WZORZEC/ZAMIANA/egimosx
               Szuka w lacuchu wzorca, a jeli go znajdzie, to zamienia go
               tekstem zamiany i zwraca liczb zamian. W przeciwnym wypadku
               zwraca falsz (specyficznie pusty lacuch).

               Jeli przez operator =~ lub !~ nie podano lacucha, uywana jest
               zmienna $_. (Lacuch podany przez =~ musi by zmienn skalarn,
               elementem tablicy, tablicy asocjacyjnej, lub przypisaniem do
               jednego z nich, czyli lwartoci.)

               Jeli wybrany ogranicznik jest pojedynczym cudzyslowem, nie
               dokonywana jest interpolacja ani zmiennych WZORCA, ani ZAMIANY.
               W przeciwnym wypadku, jeli WZORZEC zawiera $, ktory wyglda
               bardziej jak zmienna, ni test koca lacucha, zmienna bdzie
               interpolowana w czasie dzialania.  Jeli chcesz, by wzorzec byl
               kompilowany tylko raz, za pierwsz interpolacj zmiennej, uyj
               opcji /o. Jeli wzorzec jest analizowany jako lacuch null,
               uzywane jest zamiast tego ostatnie normalne wyraenie regularne.
               Zobacz jeszcze podrcznik perlre(1).  Zobacz te perllocale(1),
               aby dowiedzie si o wplywie use locale.

               Opcje to:

                   e   Analizuj praw stron jako wyraenie
                   g   Zamieniaj globalnie
                   i   Nie zwracaj uwagi na wielko liter
                   m   Traktuj lacuch jak wiele linii
                   o   Kompiluj wzorzec tylko raz
                   s   Traktuj lacuch jako pojedyncz lini
                   x   Uyj rozszerzonych wyrae regularnych

               Ukoniki mog by zamienione przez dowolny, niealfanumeryczny i
               niebialospacjowy ogranicznik. Jeli uyte s pojedyncze
               cudzyslowy, nie dokonywana jest interpretacja lacucha zamiany
               (modyfikator /e przecia to zachowanie). W przeciwniestwie do
               perla 4, perl 5 traktuje odwrotne cudzyslowy jako normalne
               ograniczniki; tekst zamiany nie jest wykonywany jako komenda.
               Jeli WZORZEC jest rozdzielany cytatami nawiasowymi, ZAMIANA ma
               swoj wlasn par cytatow, ktora moe, lub nie, by cytatami
               nawiasowymi, np.  s(foo)(bar) lub s<foo>/bar/.  /e spowoduje, e
               porcja zamiany zostanie zinterpretowana jako pelne perlowe
               wyraenie i zeval()owana zaraz potem. Jego skladnia jest jednak
               sprawdzania podczas kompilacji.

               Przyklady:

                   s/\bgreen\b/mauve/g;                # nie zmieniaj wintergreen

                   $path =~ s|/usr/bin|/usr/local/bin|;

                   s/Login: $foo/Login: $bar/; # wzorzec czasu dzialania

                   ($foo = $bar) =~ s/this/that/;

                   $count = ($paragraph =~ s/Mister\b/Mr./g);

                   $_ = 'abc123xyz';
                   s/\d+/$&*2/e;               # daje 'abc246xyz'
                   s/\d+/sprintf("%5d",$&)/e;  # daje 'abc  246xyz'
                   s/\w/$& x 2/eg;             # daje 'aabbcc  224466xxyyzz'

                   s/%(.)/$percent{$1}/g;      # zmie eskejpy procentowe; bez /e
                   s/%(.)/$percent{$1} || $&/ge;       # teraz z wyraenim, z /e
                   s/^=(\w+)/&pod($1)/ge;      # uyj wywolania funkcji

                   # /e mog si zagnieda; to rozwinie
                   # proste zmienne osadzone w $_
                   s/(\$\w+)/$1/eeg;

                   # Usu komentarze C
                   $program =~ s {
                       /\*     # Traf na rozdzielacz otwierajcy.
                       .*?     # Traf w minimaln liczb znakow.
                       \*/     # Traf w rozdzielacz zamykajcy.
                   } []gsx;

                   s/^\s*(.*?)\s*$/$1/;        # odetnij bial spacj

                   s/([^ ]*) *([^ ]*)/$2 $1/;  # zamie 1-sze 2 pola

               Zauwa, e w ostatnim przykladzie zamiast $ uyto \. W
               przeciwiestwie do sed(1)a, uywamy postaci \<cyfra> tylko po
               lewej stronie.  Wszdzie indziej, jest to $<cyfra>.

               Czasami nie mona uy po prostu /g, aby zaszly wszystkie zmiany.
               Oto dwa popularne przypadki:

                   # wstaw przecinki we wlaciwych miejscach integera
                   1 while s/(.*\d)(\d\d\d)/$1,$2/g;      # perl4
                   1 while s/(\d)(\d\d\d)(?!\d)/$1,$2/g;  # perl5

                   # rozwi tabulacje na 8-kolumnowe spacje
                   1 while s/\t+/' ' x (length($&)*8 - length($`)%8)/e;

       tr/LISTASZUKANIA/LISTAZAMIANY/cds

       y/LISTASZUKANIA/LISTAZAMIANY/cds
               Tlumaczy wszystkie pojawienia si znakow, znalezione w licie
               szukania, na odpowiadajce znaki z listy zamiany. Zwraca liczb
               zamienionych, lub skasowanych znakow. Jeli nie podano lacucha w
               operatorze =~ lub !~, uywane jest $_. (Lacuch okrelony przez =~
               musi by zmienn skalarn, elementem tablicy, elementem tablicy
               asocjacyjnej, lub przypisaniem do jednego z nich, czyli
               lwartoci).  Dla milonikow edytora sed(1), udostpniono synonim
               tr pod nazw y. Jeli LISTASZUKANIA jest rozdzielona nawiasami,
               to LISTAZAMIANY nie musi ich mie, np.  tr[A-Z][a-z] lub
               tr(+-*/)/ABCD/.

               Opcje:

                   c   Dopelnij LISTSZUKANIA
                   d   Kasuj znalezione, lecz niezamienione znaki
                   s   Zmiad zduplikowane zamienione znaki

               Jeli podany jest modyfikator /c, zbior znakow z LISTYSZUKANIA
               jest dopelniany. Jeli podany jest modyfikator /d, wszelkie
               znaki, podane w LICIESZUKANIA, a nie znalezione w LICIEZAMIANY
               s kasowane.  Jeli podany jest modyfikator /s, to sekwencje,
               ktore zostaly przetlumaczone do tego samego znaku s miadone do
               pojedynczej instancji tego znaku.

               Jeli uyty jest modyfikator /d, LISTAZAMIANY jest zawsze
               interpretowana tak, jak jest podana. W przeciwnym wypadku, gdy
               LISTAZAMIANY jest krotsza ni LISTASZUKANIA, ostatni jej znak
               jest replikowany tak dlugo, a wypelni brakujce miejsca. Jeli
               LISTAZAMIANY jest null, to replikowana jest LISTASZUKANIA.
               Jest to przydatne do zliczania znakow w klasie, lub dla
               miadenia sekwencji znakowych klasy.

               Przyklady:

                   $ARGV[1] =~ tr/A-Z/a-z/;    # zmie na male litery

                   $cnt = tr/*/*/;             # zlicz gwiazdy w $_

                   $cnt = $sky =~ tr/*/*/;     # zlicz gniazdy w $sky

                   $cnt = tr/0-9//;            # zlicz cyfry w $_

                   tr/a-zA-Z//s;               # bookkeeper -> bokeper

                   ($HOST = $host) =~ tr/a-z/A-Z/;

                   tr/a-zA-Z/ /cs;             # zmie niealfabetyczne na spacje

                   tr [\200-\377]
                      [\000-\177];             # skasuj 8-my bit

               Jeli dla znaku podano wiele translacji, uywana jest tylko
               pierwsza:

                   tr/AAA/XYZ/

               przetlumaczy A na X.

               Zauwa, e z uwagi na to, e tablica translacji jest budowana w
               czasie kompilacji, ani LISTASZUKANIA, ani LISTAZAMIANY nie
               podlegaj interpolacji cudzyslowowej. Znaczy to, e jeli chcesz
               uywa zmiennych, musisz uy eval():

                   eval "tr/$oldlist/$newlist/";
                   die $@ if $@;

                   eval "tr/$oldlist/$newlist/, 1" or die $@;

       Operatory I/O

       Istnieje wiele operatorow I/O (wejcia/wyjcia), o ktorych powiniene
       wiedzie.  Lacuch ujty w odwrotne cudzyslowy podlega najpierw
       podstawieniu zmiennych, podobnie jak lacuch ujty w podwojne cudzyslowy.
       Nastpnie jest interpretowany jako komenda, a jej wyjcie jest wartoci
       pseudoliteralu, jak w powloce. W kontekcie skalarnym, zwracany jest
       pojedynczy lacuch, skldajcy si z calego wyjcia. W kontekcie listowym,
       zwracana jest lista wartoci dla kadej linii wyjcia. (Mona ustawi $/, co
       przeciy domylny terminator linii.)  Komenda jest wykonywana przy kadej
       analizie pseudoliteralu. Status komendy jest zwracany do $? (zobacz
       podrcznik perlvar(1)).  W przeciwiestwie do csh(1), nie jest na danych
       zwracanych dokonywana translacja -- nowe linie pozostaj nowymi liniami.
       W przeciwiestwie do wszelkich innych powlok, pojedyncze cudzyslowyu nie
       ukrywaj nazw zmiennych w komendzie od interpretacji. Aby przekaza $
       dalej, naley go wycytowa odwrotnym ukonikiem.  Ogoln postaci odwrotnych
       cudzyslowow jest qx//. (Poniewa podlegaj one zawsze rownie rozwiniciu
       przez powlok, zobacz podrcznik perlsec(1), ktory opisuje problemy
       bezpieczestwa.)

       Analiza uchwytu pliku, ktory jest w nawiasach trojktnych, wyciga z
       pliku nastpn lini, lub undef na jego kocu.  Normalnie, musisz zmiennej
       przypisa warto, lecz jest sytuacja, w ktorej nastpuje automatyczne
       przypisanie. Jeli i TYLKO jeli symbol wejcia jest jedyn rzecz wewntrz
       warunku ptli while lub for(;;), to warto jest przypisywana
       automatycznie zmiennej $_. Przypisana warto jest potem sprawdzana, by
       zobaczy czy jest zdefiniowane (Moe si to wydawa troch dziwne, lecz
       bdziesz uywa tej konstrukcji w prawie kadym swoim skrypcie perlowym.)
       Nastpujce linijki s sobie rownowane:

           while (defined($_ = <STDIN>)) { print; }
           while (<STDIN>) { print; }
           for (;<STDIN>;) { print; }
           print while defined($_ = <STDIN>);
           print while <STDIN>;

       Uchwyty plikow STDIN, STDOUT i STDERR to uchwyty predefiniowane.
       Uchwyty stdin, stdout i stderr te bd dziala, lecz nie w pakietach, w
       ktorych s interpretowane jako lokalne identyfikatory nie za jako
       globalne.)  Dodatkowe uchwyty plikow mona tworzy funkcj open(). Zobacz
       jej opis w podrczniku perlfunc(1).

       Jeli <UCHWYTPLIKU jest uywany w kontekcie, oczekujcym listy, zwracana
       jest lista, skladajca si ze wszystkich linii wejciowych, jedna linia na
       element listy. Latwo jest zaj tak duy obszar danych, wic uywaj tego
       ostronie.

       Zerowy uchwyt pliku <> jest specjalny i moe by uywany do emulacji
       zachowania edytora sed(1), lub awk(1). Wejcie z <> moe nadchodzi
       zarowno ze standardowego wejcia, lub z kadego pliku, wymienionego w
       linii komend. Oto jak to dziala: za pierwsz analiz <>, sprawdzana jest
       tablica @ARGV i jeli jest zerowa, $ARGV[0] jest ustawiane na "-", co
       oznacza po otwarciu standardowe wejcie. Tablica @ARGV jest nastpnie
       przetwarzana jako lista nazw plikow.  Ptla

           while (<>) {
               ...                     # kod dla kadej linii
           }

       jest rownowana nastpujcemu pseudokodowi:

           unshift(@ARGV, '-') unless @ARGV;
           while ($ARGV = shift) {
               open(ARGV, $ARGV);
               while (<ARGV>) {
                   ...         # kod dla kadej linii
               }
           }

       poza tym, e jest troch ladniejsza i dziala. Naprawd przesuwa tablic
       @ARGV i wstawia biec nazw pliku do zmiennej $ARGV.  Uywa te wewntrznie
       uchwytu ARGV--<> jest po prostu synonimem <ARGV>, ktory jest magiczny.
       (Powyszy pseudokod nie dziala, gdy traktuje ARGV amagicznie.)

       Przed pierwszym <> moesz modyfikowa @ARGV, o ile tablica bdzie
       zawierala list plikow, ktorych oczekujesz. Numey linii ($.) s liczone
       tak, jakby wejcie bylo tylko jednym, szczliwym plikiem. (Lecz zobacz
       przyklad z eof(), aby zobaczy jak zresetowa numery linii.)

       Jeli chcesz ustawi @ARGC na swoj wlasn list plikow, to nie ma sprawy.
       Jeli chcesz przekaza do swojego skryptu przelczniki, moesz uy jednego z
       modulow Getopts, lub wstawi na pocztku podobn ptl:

           while ($_ = $ARGV[0], /^-/) {
               shift;
               last if /^--$/;
               if (/^-D(.*)/) { $debug = $1 }
               if (/^-v/)     { $verbose++  }
               ...             # inne przelczniki
           }
           while (<>) {
               ...             # kod dla kadej linii
           }

       Symbol <> zwraca FALSE tylko raz. Jesli wywolasz go po tym, zaloy, e
       przetwarzasz now list @ARGV i jeli jej nie ustawile, pobierze wejcie ze
       STDIN.

       Jeli lacuch wewntrz nawiasow trojktnych jest wskazaniem do zmiennej
       skalarnej (np. <$foo>), to zmienna ta przechowuje nazw uchwytu, z
       ktorego pobierane jest wejcie. Np:

           $fh = \*STDIN;
           $line = <$fh>;

       Lacuch w nawiasach trojktnych nie jest uchwytem pliku, to jest
       interpretowany jako wzorzec nazwy pliku do glob()owania i zwracana jest
       albo lista nazw pliku lub nastpna nazwa pliku (zalenie od kontekstu).
       Najpierw dokonywany jest jeden poziom interpretacji $, lecz nie mona
       powiedzie <$foo>, gdy jest to niebezporedni uchwyt pliku, opisany w
       poprzednim paragrafie. (W starszych wersjach perla, programici mogli
       wstawia nawiasy do wymuszania interpretacji jako nazwy pliku do
       globowania: <${foo}>. Dzi jednak, za czystsze uwaa si bezporednie
       wolanie funkcji wewntrznej -- glob($foo). Przyklad:

           while (<*.c>) {
               chmod 0644, $_;
           }

       jest rownowany

           open(FOO, "echo *.c | tr -s ' \t\r\f' '\\012\\012\\012\\012'|");
           while (<FOO>) {
               chop;
               chmod 0644, $_;
           }

       W rzeczywistoci, obecnie jest to wlanie tak zaimplementowane. (Co
       znaczy, e nie bdzie dziala na nazwach plikow ze spacjami, chyba e masz
       u siebie csh(1).) Oczywicie najkrotszym sposobem dokonania powyszego
       jest:

           chmod 0644, <*.c>;

       Poniewa globowanie uywa powloki, czsto szybciej jest wywola
       samodzielnie readdir() i dokona grep()a na nazwach plikow. Co wicej, z
       powodu obecnej implementacji, wywolanie glob() moe napotka bldy w
       rodzaju "Arg list too long" (chyba e zainstalowale tcsh(1L) jako
       /bin/csh).

       Glob analizuje swoj (osadzony) argument tylko jeli rozpoczyna now list.
       Wszystkie wartoci musz by odczytane zanim znow rozpocznie. W kontekcie
       listowym nie jest to istotne, gdy autmatycznie odczytujesz wszystkie.
       Jednak w kontekcie skalarnym, operator zwraca nastpn warto za kadym
       wywolaniem, lub FALSE na kocu. Znowu, FALSE jest zwracane tylko raz.
       Jeli wic oczekujesz od globa pojedynczej wartoci, to lepiej powiedzie

           ($file) = <blurch*>;

       a nie

           $file = <blurch*>;

       gdy to drugie bdzie rozronia zwrocenie nazwy plikow i zwrocenie FALSE.

       Jeli probujesz dokona interpolacji zmiennych, to zdecydowanie lepiej
       jest uy funkcji glob(), gdy starsza notacja moe spowodowa zaklopotanie
       u niektorych osob.

           @files = glob("$dir/*.[ch]");
           @files = glob($files[$i]);

       Zawijanie sta/l/lych

       Podobnie jak C, perl posiada pewien zestaw analiz wyrae, wykonywanych
       podczas kompilacji -- dzieje si to jeli zauway, e wszystkie argumenty
       operatora  s statyczne i nie maj efektow ubocznych. W szczegolnoci, np.
       konkatenacja literalow bez podstawie zmiennych jest dokonywana podczas
       kompilacji. Interpretacja odwrotnych ukonikow nastpuje rownie podczas
       kompilacji. Moesz powiedzie

           'Now is the time for all' . "\n" .
               'good men to come to.'

       a wszystko to wewntrznie zredukuje si do jednego lacucha. Podobnie,
       jeli powiesz

           foreach $file (@filenames) {
               if (-s $file > 5 + 100 * 2**16) { ... }
           }

       to kompilator przeliczy liczby, ktore reprezentuje wyraenie.

       Arytmetyka ca/l/lkowita

       Domylnie, perl wykonuje wszystkie obliczenia zmiennoprzecinkowo. Jednak
       powiedzenie

           use integer;

       mowi kompilatorowi, e moe uywa odtd, do koca bloku operacji
       calkowitych. Wewntrzne bloki mog temu zaprzeczy, mowic

           no integer;

       co wystarcza do koca ich bloku.

       Operatory bitowe ("&", "|", "^", "~", "<<", i ">>") zawsze daj wyniki
       calkowite. Jednak use integer ma wci dla nich znaczenie. Domylnie ich
       wyniki s interpretowane jako liczby calkowite bez znaku. Po wlczeniu
       tej opcji, sa interpretowane ze znakiem.  Np. ~0 normalnie jest
       analizowane do wielkiej wartoci calkowitej.  Po use integer; ~0 staje
       si -1.

       Arytmetyka zmiennoprzecinkowa

       Podczas gdy use integer daje arytmetyk calkowit, nie ma podobnej
       instrukcji dla dawania zaokrgle, lub odci w konkretnych miejscach
       dziesitnych. Dla zaokrgle do okrelonej iloci cyfr, najlepiej uy
       sprintf() lub printf().

       Modul POSIX (cz standardowej dystrybucji perla) implementuje funkcje
       ceil(), floor() i kilka innych funkcji matematycznych i
       trygonometrycznych. Modul Math::Complex (rownie standardowy) definiuje
       sporo funkcji matematycznych, ktore mog dziala rownie na liczbach
       rzeczywistych. Modul Math::Complex nie jest tak wydajny jak POSIX, lecz
       POSIX nie moe dziala na liczbach zespolonych.

       Zaokrglanie w aplikacjach finansowych moe mie powane konsekwencje i
       uywana metoda powinna by podawana dokladnie. W tych wypadkach, lepiej
       nie ufa temu, ktory system zaokrglania jest uywany przez perla, lecz
       zaimplementowa tak funkcj samodzielnie.

INFORMACJE O T/L/LUMACZENIU

       Powysze tlumaczenie pochodzi z nieistniejcego ju Projektu Tlumaczenia
       Manuali i moe nie by aktualne. W razie zauwaenia ronic midzy powyszym
       opisem a rzeczywistym zachowaniem opisywanego programu lub funkcji,
       prosimy o zapoznanie si z oryginaln (angielsk) wersj strony podrcznika.