Linux Certif

Toute la documentation sur la certification Linux LPI

perlop

NAZWA

perlop - operatory perla i priorytety

STRESZCZENIE

Operatory perla maj± nastêpuj±ce zwi±zki i priorytety, wymienione od najwy¿szych do najni¿szych. Zauwa¿, ¿e wszystkie operatory po¿yczone z C zachowuj± tamtejsze zwi±zki, choæ te konwencje s± trochê skopane. (U³atwia to naukê perla programistom C.) Poza paroma wyj±tkami, wszystkie one operuj± na warto¶ciach skalarnych, nie tablicowych.

    lewe        wyra¿enia i lewostronne operatory list

    lewe        ->

    niezwi±zane ++ --

    prawe       **

    prawe       ! ~ \ and jednoargumentowy + and -

    lewe        =~ !~

    lewe        * / % x

    lewe        + - .

    lewe        << >>

    niezwi±zane nazwane operatory jednoargumentowe

    niezwi±zane < > <= >= lt gt le ge

    niezwi±zane == != <=> eq ne cmp

    lewe        &

    lewe        | ^

    lewe        &&

    lewe        ||

    niezwi±zane ..  ...

    prawe       ?:

    prawe       = += -= *= etc.

    lewe        , =>

    niezwi±zane prawostronne operatory list

    prawe       not

    lewe        and

    lewe        or xor

W nastêpuj±cych sekcjach, operatory te s± opisane w kolejno¶ci priorytetowej.

OPIS

Wyra¿enia i lewostronne operatory list

Wyra¿enie ma w perlu najwy¿szy priorytet. S± to zmienne, cytaty, operatory w rodzaju cytatów, dowolne wyra¿enie w nawiasach, i dowolna funkcja, której argumenty s± umieszczone w nawiasach. W rzeczywisto¶ci, w perlu nie ma tak naprawdê funkcji w ogólnym sensie, s± tylko operatory listowe i operatory jednoargumentowe, zachowuj±ce siê jak funkcje, bo ustawiasz wokó³ nich nawiasy. S± one opisane w podrêczniku perlfunc(1).

Je¶li dowolny operator listowy (print() itp.), lub dowolny operator jednoargumentowy (chdir()) ma za sob± lewy nawias, to operator i argumenty z nawiasów s± brane w najwy¿szym priorytecie, tak jak przy normalnym wywo³aniu funkcji.

Gdy nawiasy nie s± podane, priorytet operatorów listowych w rodzaju print, sort, lub chmod jest albo bardzo wysoki, albo bardzo niski, zale¿nie od tego czy patrzysz na lew± stronê, czy na praw± stronê operatora. Na przyk³ad 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 pó¼niej. Innymi s³owy, operatory listowe po¿eraj± wszystkie argumenty, które za nimi nastêpuj±, a potem zachowuj± siê jak proste wyra¿enie, szanuj±ce wyra¿enie poprzedzaj±ce. Zauwa¿, ¿e musisz byæ ostro¿ny 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 wyra¿enia przetwarzane s± te¿ konstrukcje do {} i eval {}, a tak¿e wywo³ania podprocedur i metod, oraz anonimowe konstruktory [] i {}.

Zobacz te¿ sekcjê o operatorach cytowania, a tak¿e sekcjê o operatorach I/O.

Operator strza³ki

Podobnie jak w C i C++, ``->'' jest operatorem dereferencji. Je¶li prawa strona to element [...] lub {...}, to lewa strona musi byæ tward±, lub symboliczn± referencj± do tablicy, lub tablicy asocjacyjnej (lub miejsca, które jest w stanie przechowywaæ tward± referencjê, je¶li jest to lwarto¶æ (przypisywalna)). Zobacz stronê perlref(1).

W przeciwnym wypadku, prawa strona jest nazw± metody, lub prost± zmienn± skalarn±, zawieraj±c± nazwê metody, a lewa strona musi byæ albo obiektem (pob³ogos³awion± przez bless referencj±), lub nazw± klasy (tj. nazw± pakietu). Zobacz stronê perlobj(1).

Auto-inkrementacja i Auto-dekrementacja

``++'' i ``--'' dzia³aj± jak w C. To znaczy, je¶li s± umieszczone przed zmienn±, to inkrementuj± lub dekrementuj± zmienn± przed zwróceniem warto¶ci, a je¶li s± umieszczone za zmienn±, to powoduj± inkrementacjê lub dekrementacjê po zwróceniu warto¶ci.

Operator auto-inkrementacji ma wbudowanych parê dodatkowych rzeczy. Je¶li inkrementujesz zmienn±, która jest numeryczna, lub która by³a kiedykolwiek u¿yta w kontek¶cie numerycznym, to uzyskasz normaln± inkrementacjê. Jednak je¶li zmienna by³a u¿ywana tylko w kontekstach ³añcuchowych, a jej warto¶æ nie jest nullem i odpowiada wzorcowi /^[a-zA-Z]*[0-9]*$/, to inkrementacja jest dokonywana jak na ³añcuchu, zachowuj±c ka¿dy 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 w³a¶ciwo¶ci.

Potêga

Binarny ``**'' jest operatorem potêgowania. Zauwa¿, ¿e ³±czy mocniej ni¿ jednoargumentowy minus, wiêc -2**4 to -(2**4), a nie (-2)**4. (Jest to zaimplementowane przy u¿yciu funkcji pow(3) z C, która w rzeczywisto¶ci dzia³a na liczbach typu podwójnej precyzji.)

Symboliczne operatory jednoargumentowe

Jednoargumentowy ``!'' wykonuje negacjê logiczn±, czyli ``not''. Zobacz te¿ not dla wersji o ni¿szym priorytecie.

Jednoargumentowy ``-'' dokonuje arytmetycznej negacji na numerycznym operandzie. Je¶li operand jest identyfikatorem, zwracany jest ³añcuch sk³adaj±cy siê ze znaku minus i z identyfikatora. W przeciwnym wypadku, je¶li ³añcuch rozpoczyna siê znakiem plus lub minus, zwracany jest ³añcuch z przeciwnym znakiem. Jednym z efektów tego dzia³ania jest to, ¿e -bareword jest równowa¿ne "-bareword".

Jednoargumentowy ``~'' dokonuje negacji bitowej. (Zobacz te¿ sekcjê o arytmetyce ca³kowitej.)

Jednoargumentowy ``+'' nie daje ¿adnego efektu, nawet na ³añcuchach. Jest przydatny do rozdzielania nazwy funkcji od otoczonego nawiasami wyra¿enia, które w przeciwnym wypadku by³oby interpretowane jako ca³kowita lista argumentów funkcji. (Zobacz przyk³ady w sekcji o wyra¿eniach i lewostronnych operatorach listowych.)

Jednoargumentowy ``\'' tworzy referencjê do tego, co po nim nastêpuje. Zobacz podrêcznik perlref(1). Nie myl tego zachowania z zachowaniem w ³añcuchu odwrotnego uko¶nika, choæ obie postacie maj± tê sam± w³a¶ciwo¶æ chronienia nastêpnej rzeczy od interpretacji.

Operatory ³±czenia

Binarny ``=~'' ³±czy wyra¿enie skalarne z obs³ug± wyra¿enia regularnego. Pewne operacje domy¶lnie szukaj± lub zmieniaj± ³añcuch $_. Operator ten powoduje, ¿e taka operacja dzia³a na innym ³añcuchu. Prawy argument jest wzorcem przeszukiwania, podstawienia lub translacji. Lewy argument jest przeszukiwanym ³añcuchem, zamiast domy¶lnego $_. Warto¶æ zwracana okre¶la sukces operacji. (Je¶li prawy argument jest raczej wyra¿eniem ni¿ wzorcem przeszukiwania, podstawiania lub translacji, to jest interpretowany jako wzorzec przeszukiwania czasu dzia³ania. Mo¿e to byæ mniej efektywne ni¿ jawne szukanie, gdy¿ wzorzec musi byæ za ka¿dym razem kompilowany.

[Przyp. t³um: Na przyk³ad "$lancuch="bla"; $lancuch=~s/l/q/; print $lancuch" da w wyniku ³añcuch "bqa".]

Binarny ``!~'' jest podobny do ``=~'' lecz warto¶æ zwracana jest logicznie negowana.

Operatory mno¿enia

Binarny ``*'' mno¿y dwie liczby.

Binarny ``/'' dzieli dwie liczby.

Binarny ``%'' oblicza resztê (modulo) z dwóch liczb. Z ca³kowitymi operandami $a i $b: je¶li $b jest dodatnie, to $a % $b to $a minus najwiêksza wielokrotno¶æ $b, która nie jest wiêksza od $a. Je¶li $b jest ujemne, to $a % $b to $a minus najmniejsza wielokrotno¶æ $b, która nie jest mniejsza ni¿ $a (np. wynik bêdzie mniejszy lub równy od zera).

Binarny ``x'' jest operatorem powtórzenia. W kontek¶cie skalarnym, zwraca ³añcuch sk³adaj±cy siê z lewego operanda, powtórzonego tyle razy, ile podano w prawym. W kontek¶cie listowym, je¶li 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ê dwóch liczb.

Binarny ``-'' zwraca ró¿nicê dwóch liczb.

Binarny ``.'' ³±czy (konkatenuje) ³añcuchy.

Operatory przesuwania

Binanry ``<<'' zwraca warto¶æ swojego lewego argumentu, przesuniêtego w lewo o ilo¶æ bitów, podan± w prawym argumencie. Argumenty powinny byæ liczbami ca³kowitymi. (Zobacz te¿ sekcjê o arytmetyce ca³kowitej.)

Binarny ``>>'' zwraca warto¶æ swojego lewego argumentu, przesuniêtego w prawo o ilo¶æ bitów, podan± w prawym argumencie. Argumenty powinny byæ liczbami ca³kowitymi.

Nazwane operatory jednoargumentowe

Ró¿ne nazwane operatory jednoargumentowe s± traktowane jak jednoargumentowe funkcje, z opcjonalnymi nawiasami. S± to m.in testy plikowe, itp. Zobacz podrêcznik perlfunc(1).

Je¶li za dowolnym operatorem listowym (print() itp.), lub operatorem jednoargumentowym (chdir() itp.) nastêpuje lewy nawias, to operator i argumenty w nawiasach s± brane z najwy¿szym priorytetem, tak jak przy wywo³aniu funkcji. Przyk³ady:

    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 wy¿szy 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 wyra¿eniach i lewostronnych operatorach listowych.

Operatory relacji

Binarny ``<'' zwraca prawdê, je¶li lewy argument jest numerycznie mniejszy ni¿ prawy.

Binarny ``>'' zwraca prawdê, je¶li lewy argument jest numerycznie wiêkszy ni¿ prawy.

Binarny ``<='' zwraca prawdê, je¶li lewy argument jest numerycznie mniejszy lub równy prawemu.

Binarny ``>='' zwraca prawdê, je¶li lewy argument jest numerycznie wiêkszy lub równy prawemu.

Binarny ``lt'' zwraca prawdê, je¶li lewy argument jest ³añcuchowo mniejszy od prawego.

Binarny ``gt'' zwraca prawdê, je¶li lewy argument jest ³añcuchowo wiêkszy od prawego.

Binarny ``le'' zwraca prawdê, je¶li lewy argument jest ³añcuchowo mniejszy lub równy prawemu.

Binarny ``ge'' zwraca prawdê, je¶li lewy argument jest ³añcuchowo wiêkszy lub równy prawemu.

Operatory równo¶ci

Binarny ``=='' zwraca prawdê, je¶li lewy argument jest numerycznie równy prawemu.

Binarny ``!='' zwraca prawdê, je¶li lewy argument nie jest numerycznie równy prawemu.

Binarny ``<=>'' zwraca -1, 0, lub 1, zale¿nie od tego czy lewy argument jest numerycznie mniejszy, równy, lub wiêkszy od prawego.

Binarny ``eq'' zwraca prawdê, je¶li lewy argument jest ³añcuchowo równy prawemu.

Binarny ``ne'' zwraca prawdê, je¶li lewy argument nie jest ³añcuchowo równy prawemu.

Binarny ``cmp'' zwraca -1, 0, lub 1, zale¿nie od tego, czy lewy argument jest ³añcuchowo mniejszy, równy, lub wiêkszy od prawego.

``lt'', ``le'', ``ge'', ``gt'' i ``cmp'' mog± u¿ywaæ kolejno¶ci sortowania, okre¶lonej przez bie¿±ce locale (gdy u¿yte jest use locale). Zobacz podrêcznik perllocale(1).

Bitowy And

Binarny ``&'' zwraca jego operatory, po³±czone bitowo operacj± logiczn± AND. (Zobacz te¿ sekcjê o arytmetyce ca³kowitej.)

Bitowy i Xor (eXclusive Or)

Binarny ``|'' zwraca swoje operatory, po³±czone bitowo operacj± logiczn± OR. (Zobacz te¿ sekcjê o arytmetyce ca³kowitej).

Binarny ``^'' zwraca swoje operatory, po³±czone bitowo operacj± XOR. (Zobacz te¿ sekcjê o arytmetyce ca³kowitej.)

Logiczny And w stylu C

Binarny ``&&'' dokonuje logicznej operacji AND. Je¶li lewy operand jest fa³szywy (false), to prawy nie jest nawet analizowany. Kontekst skalarny, lub listowy propaguje do prawego operatora, je¶li jest on analizowany.

Logiczny w stylu C

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

Operatory || i && ró¿ni± siê od C tym, ¿e zwracaj± ostatni± analizowan± warto¶æ zamiast 0 czy 1. Tak wiêc przeno¶nym sposobem znalezienia katalogu domowego (zak³adaj±c, ¿e nie jest ``0"), mo¿e byæ:

    $home = $ENV{'HOME'} || $ENV{'LOGDIR'} ||

        (getpwuid($<))[7] || die "You're homeless!\n";

Jako czytelniejsze alternatywy && i ||, perl udostêpnia operatory ``and'' i ``or'' (patrz ni¿ej). Zachowanie jest identyczne. Jednak ich priorytet jest ni¿szy, wiêc mo¿esz ich bezpiecznie u¿ywaæ po operatorze listowym, bez konieczno¶ci u¿ywania nawiasów:

    unlink "alpha", "beta", "gamma"

            or gripe(), next LINE;

Z u¿yciem operatorów w stylu C, trzeba by by³o to zapisaæ jako:

    unlink("alpha", "beta", "gamma")

            || (gripe(), next LINE);

Operator zakresu

Binarny ``..'' jest operatorem zakresu, który jest w rzeczywisto¶ci dwoma innymi operatorami, zale¿nymi od kontekstu. W kontek¶cie listowym, zwraca tablicê warto¶ci, liczon± (po jednym) od warto¶ci lewej do prawej. Jest to przydatne do zapisywania pêtli for (1..10) i robienia operacji wycinania (slice) na tablicach. B±d¼ ¶wiadom, ¿e w bie¿±cej implementacji tworzona jest tymczasowa tablica, wiêc potrzeba na to trochê pamiêci, je¶li zapiszesz co¶ takiego:

    for (1 .. 1_000_000) {

        # kod

    }

W kontek¶cie skalarnym, ``..'' zwraca warto¶æ logiczn±. Operator jest dwustanowy, jak flip-flop i emuluje operator zakresu liniowego (przecinek) z sed(1), awk(1) i ró¿nych edytorów. Ka¿dy operator ``..'' obs³uguje swój w³asny stan logiczny. Jest on fa³szywy tak d³ugo, jak d³ugo lewy operand jest fa³szywy. Gdy lewy operand stanie siê prawdziwy, operator zakresu pozostaje prawdziwy dopóki prawy argument jest prawd±, PO czym, operator zakresu przyjmuje warto¶æ fa³szu. (Nie staje siê fa³szywym do czasu nastêpnej jego analizy. Mo¿e testowaæ prawy operand i staæ siê fa³szywym w tej samej analizie, kiedy sta³ siê prawdziwym (jak w awk(1)), lecz wci±¿ bêdzie raz zwraca³ prawdê. Je¶li nie chcesz by testowa³ prawy operand przed nastêpn± analiz± (jak w sed(1)), u¿yj trzech kropek (''...") zamiast dwóch.) Prawy operand nie jest analizowany podczas gdy operator jest w stanie fa³szu, a lewy operand nie jest analizowany gdy operator jest w stanie prawdy. Priorytet jest trochê ni¿szy ni¿ || i &&. Zwracana warto¶æ jest albo ³añcuchem null dla fa³szu, lub liczb± sekwencyjn± (zaczynaj±c± siê od 1) dla prawdy. Liczba sekwencyjna jest resetowana dla ka¿dego napotkanego zakresu. Koñcowa liczba sekwencyjna w zakresie ma doklejony ³añcuch ``E0®", który nie ma jednak wp³ywu na warto¶æ numeryczn±, a za to daje co¶, czego mo¿esz oczekiwaæ na koñcu. Mo¿esz wy³±czyæ punkt pocz±tkowy przez oczekiwanie a¿ liczba sekwencyjna stanie siê wiêksza ni¿ jeden. Je¶li który¶ z operandów skalarnego ``..'' jest litera³em numerycznym, operand jest niejawnie porównywany ze zmienn± $., bie¿±cym numerem linii. Przyk³ady

Jako operator skalarny:

    if (101 .. 200) { print; }  # wydrukuj drug± setkê linii

    next line if (1 .. /^$/);   # pomiñ linie nag³ówka [pocztowego]

    s/^/> / if (/^$/ .. eof()); # Cytuj cia³o

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 elementów

Operator zakresu (w kontek¶cie listowym) u¿ywa w wypadku gdy operandy s± ³añcuchami magicznego algorytmu autoinkrementacji. Mo¿esz 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 pocz±tkowymi zerami. Je¶li ostatnia podana warto¶æ nie jest w sekwencji, któr± daje magiczna inkrementacja, to sekwencja idzie tak daleko, a¿ nastêpna warto¶æ nie bêdzie d³u¿sza ni¿ podana ostatnia warto¶æ.

Operator warunkowy

``?:'' jest operatorem warunkowym, zupe³nie jak w C. Dzia³a podobnie do konstrukcji if-then-else. Je¶li argument przed ? jest prawdziwy, to zwracany jest argument przed :. W przeciwnym wypadku, zwracany jest argument po :. Na przyk³ad:

    printf "Mam %d ps%s.\n", $n,

            ($n == 1) ? "a" : "y";

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

    $a = $ok ? $b : $c;  # we¼ skalar

    @a = $ok ? @b : @c;  # we¼ tablicê

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

Operator mo¿e byæ przypisany je¶li obydwa argumenty -- 2-gi i 3-ci s± legalnymi lwarto¶ciami (co znaczy ¿e mo¿na do nich przypisaæ):

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

Niekoniecznie musi to jednak poprawiæ czytelno¶æ twojego programu.

Operatory przypisania

``='' jest zwyk³ym operatorem przypisania.

Operator przypisania dzia³a jak w C. Tzn,

    $a += 2;

jest równowa¿ne

    $a = $a + 2;

choæ bez powielania efektów ubocznych, które mo¿e poci±gaæ za sob± dereferencja lwarto¶ci, tak jak dla tie(). Inne operatory przypisania dzia³aj± podobnie. Rozpoznawane s± nastêpuj±ce:

    **=    +=    *=    &=    <<=    &&=

           -=    /=    |=    >>=    ||=

           .=    %=    ^=

                 x=

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

W przeciwieñstwie do C, operator przypisania daje prawid³ow± lwarto¶æ. Modyfikowanie przypisania jest równowa¿ne 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 równowa¿ne

    $a += 2;

    $a *= 3;

Operator przecinka

Binarny ``,'' jest operatorem przecinka. W kontek¶cie skalarnym analizuje swój lewy argument, wyrzuca jego warto¶æ i nastêpnie analizuje prawy argument, zwracaj±c jego warto¶æ. Jest to takie samo, jak operator przecinka z C.

W kontek¶cie listowym, jest to po prostu separator listy i wstawia obydwa argumenty do listy.

Znak => jest czêsto synonimem operatora przecinka. Przydatny jest do dokumentowania argumentów, które s± w parach. Od wersji 5.001 wymusza to te¿ interpretacjê ka¿dego s³owa z lewej jako ³añcucha.

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 ni¿szym priorytecie to operatory logiczne ``and'', ``or'', i ``not'', które mog± byæ u¿ywane do analizowania wywo³añ do operatorów listowych, bez potrzeby dodatkowych nawiasów:

    open HANDLE, "filename"

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

Zobacz te¿ dyskusjê operatorów listowych w sekcji o wyra¿eniach i operatorach listowych lewostronnych.

Logiczny Not

Jednoargumentowy ``not'' zwraca logiczn± negacjê prawego argumentu. Jest równowa¿ny ``!'', lecz ma ni¿szy priorytet.

Logiczny And

Binarny ``and'' zwraca logiczn± koniunkcjê otaczaj±cych wyra¿eñ. Jest równowa¿ny &&, lecz ma ni¿szy priorytet. Znaczy to, ¿e prawe wyra¿enie jest analizowane tylko je¶li lewe jest prawdziwe.

Logiczny or i xor

Binarny ``or'' zwraca logiczn± dyzjunkcjê otaczaj±cych wyra¿eñ. Jest równowa¿ny ||, lecz ma ni¿szy priorytet. Znaczy to, ¿e prawe wyra¿enie jest wykonywane tylko je¶li lewe jest fa³szywe.

Binarny ``xor'' zwraca XOR otaczaj±cych wyra¿eñ. Nie mo¿e byæ oczywi¶cie u¿ywany z zawê¿eniem, jak or.

Operatory C, których brakuje w perlu

Oto operatory C, których perl nie posiada:

jednoargumentowy &

Operator adresu. (Lecz zobacz opis operatora ``\''.)

jednoargumentowy *

Operator dereferencji (wy³uskania) adresu. (Perlowe przedrostkowe operatory dereferencji to: $, @, %, &.)

(TYP)

Operator konwersji typów.

Operatory cytatów i cytatopodobne

Podczas gdy normalnie my¶limy o cytatach jak o literalnych warto¶ciach, w perlu maj± one funkcjê operatorów, daj±c ró¿ne w³a¶ciwo¶ci interpolowania i porównywania wzorców. Perl daje dla tych zachowañ tradycyjne znaki cytowania, lecz równie¿ sposób na wybieranie znaku cytowania. W nastêpuj±cej tablicy, {} oznacza parê ograniczników, które wybierzesz. Ograniczniki nienawiasowe u¿ywaj± tego samego znaku na pocz±tek i koniec, ale 4 rodzaje nawiasów mog± siê zagnie¿d¿aæ.

    Zwyczajowy Standardowy Znaczenie    Interpoluje

        ''       q{}       Litera³         nie

        ""      qq{}       Litera³         tak

        ``      qx{}       Komenda         tak

                qw{}      Lista s³ów       nie

        //       m{} Porównanie ze wzorcem tak

                 s{}{}   Podstawienie      tak

                tr{}{}   Translacja        nie

Dla konstrukcji, wykonuj±cych interpolacjê, zmienne zaczynaj±ce siê od ``$'' lub ``@'' s± interpolowane jako nastêpuj±ce 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 ósemkowy

    \x1b        znak szesnastkowy

    \c[         znak steruj±cy

    \l          zmieñ nastêpny znak na ma³± literê

    \u          zmieñ nastêpny znak na du¿± literê

    \L          zmieñ na ma³± literê a¿ do \E

    \U          zmieñ na du¿± literê a¿ do \E

    \E          koniec modyfikacji rozmiaru

    \Q          cytuj metaznaki regexp a¿ do \E

Je¶li u¿ywane jest use locale, mapa rozmiarów liter odpowiada lokalnej sytuacji. Zobacz podrêcznik perllocale(1).

Wzorce s± podstaw± do innego poziomu interpretacji -- jako wyra¿enia regularne. Jest to robione jako drugi przebieg, po interpolacji zmiennych, tak ¿e wyra¿enia regularne mog± byæ w³±czane do wzorca ze zmiennych. Je¶li tego nie chcesz, u¿yj \Q.

Poza powy¿szym, nie ma wielokrotnych poziomów interpolacji. W rzeczywisto¶ci, w przeciwieñstwie do oczekiwañ programistów pow³okowych, odwrotne cudzys³owy nie interpoluj± w podwójnych cudzys³owach, a pojedyncze otoczone w podwójnych cudzys³owach nie utrudniaj± analizy zmiennych w nich zawartych.

Operatory cytatopodobne Regexp

Oto cytatopodobne operatory, które dotycz± siê dzia³añ zwi±zanych z porównywaniem wzorców.

?WZORZEC?

Jest to co¶ w rodzaju przeszukiwania /wzorzec/, lecz miêdzy wywo³aniami operatora reset(), trafienie jest jednokrotne. Jest to przydatna optymalizacja, je¶li np. chcesz zobaczyæ tylko pierwsze pojawienie siê czego¶ w pliku, lub zbiorze. Resetowane s± tylko wzorce ??, lokalne dla bie¿±cego pakietu.

To u¿ycie jest niezalecane i mo¿e byæ usuniête w przysz³ych wersjach perla.

m/WZORZEC/gimosx

/WZORZEC/gimosx

Przeszukuje wzorzec dla trafienia i w kontek¶cie skalarnym wzraca prawdê (1), lub fa³sz (''). Je¶li nie podano ¿adnego ³añcucha poprzez operator =~, lub !~, przeszukiwany jest ³añcuch $_. (£añcuch podany przez =~ nie musi byæ lwarto¶ci± --- mo¿e byæ wynikiem analizy wyra¿enia, lecz pamiêtaj, ¿e =~ wi±¿e do¶æ mocno.) Zobacz te¿ podrêcznik perlre(1). Zobacz podrêcznik perllocale(1) dla dyskusji o dodatkowych sprawach, zwi±zanych z u¿yciem use locale.

Opcje to:

    g   Porównuj globalnie, na wszystkich pojawieniach

    i   Porównuj bez zwracania uwagi na wielko¶æ liter

    m   Traktuj ³añcuch jako wielokrotne linie

    o   Kompiluj wzorzec tylko raz

    s   Traktuj ³añcuch jako pojedyncz± liniê

    x   U¿yj rozszerzonych wyra¿eñ regularnych

Je¶li ogranicznikiem jest ``/'', to pocz±tkowe m jest opcjonalne. U¿ywaj±c m, mo¿esz wykorzystaæ jako ograniczniki dowoln± parê nialfanumerycznych, niebia³ospacjowych znaków. Jest to przydatne do porównywania unixowych nazw ¶cie¿ek, które mog± zawieraæ ``/''. Zapobiega to LTS (syndrom w±skiej wyka³aczki). Je¶li ``?'' jest ogranicznikiem, to stosowana jest regu³a trafienia-tylko-raz instrukcji ?WZORZEC?.

WZORZEC mo¿e zawieraæ zmienne, które bêd± interpolowane (a wzorzec rekompilowany) za ka¿d± analiz±. (Zauwa¿, ¿e $) i $| mog± nie byæ interpolowane, gdy¿ wygl±daj± jak testy koñca ³añcucha.) Je¶li chcesz, by takie wzorce by³y kompilowane tylko raz, dodaj do ostatniego ogranicznika znak /o. Zapobiega to kosztownej kompilacji czasu dzia³ania i jest przydatne, gdy warto¶æ, z której korzystasz nie zmienia siê w czasie ¿ycia skryptu. Jednak pamiêtaj, ¿e opcja /o daje obietnicê, i¿ nie zmienisz zmiennych ze wzorca. Je¶li je zmienisz, perl tego nie zauwa¿y.

Je¶li WZORZEC zostanie zanalizowany jako ³añcuch null, to u¿yte zostanie ostatnie wykonane wyra¿enie regularne.

W kontek¶cie, wymagaj±cym warto¶ci listowej, porównanie wzorca zwraca listê, sk³adaj±c± siê z listy podwyra¿eñ, trafionych przez nawiasy z wzorca, np. ($1, $2, $3...). (Zauwa¿, ¿e ustawione tu s± równie¿ $1 itp. i ¿e ró¿ni siê to od zachowania perla 4.) Je¶li porównanie siê nie powiedzie, zwracana jest tablica null. Je¶li porównanie siê powiedzie, lecz nie bêdzie nawiasów, zwracana zostanie warto¶æ listowa (1).

Przyk³ady:

    open(TTY, '/dev/tty');

    <TTY> =~ /^y/i && foo();    # zrób foo, je¶li 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 przyk³ad dzieli $foo na pierwsze dwa s³owa i resztê linii. Przypisuje te trzy pola do $F1, $F2 i $Etc. Warunek jest prawdziwy, je¶li przypisane zosta³y warto¶ci którejkolwiek ze zmiennych, czyli je¶li wzorzec zosta³ trafiony.

Modyfikator /g okre¶la globalne porównywanie wzorców --- tj. takie, gdzie trafieñ jest tyle ile siê da w danym ³añcuchu. Zachowanie tego zale¿y od kontektu -- w listowym zwracana jest lista wszystkich pod³añcuchów, trafionych przez wszystkie nawaisy wyra¿enia regularnego. Je¶li nie by³o nawiasów, zwracana jest lista trafionych ³añcuchów, tak jakby by³y nawiasy wokó³ ca³ego wzorca.

W kontek¶cie skalarnym, ,//g iteruje poprzez ³añcuch, zwracaj±c TRUE za ka¿dym trafieniem i FALSE przy braku trafienia. (Innymi s³owy, zapamiêtuje ostatni± pozycjê i restartuje od tego miejsca. Mo¿esz znale¼æ bie¿±c± pozycjê trafienia przy u¿yciu funkcji pos(); zobacz jej opis w podrêczniku perlfunc(1).) Brak trafienia normalnie resetuje pozycjê przeszukiwania na pocz±tek ³añcucha, lecz mo¿esz temu zapobiec, dodaj±c modyfikator ``c'' (np. m//gc). Modyfikowanie ³añcucha docelowego równie¿ resetuje pozycjê przeszukiwania.

Mo¿esz mieszaæ porównania m//g z m/\G.../g, gdzie \G jest zapewnieniem zerowej szeroko¶ci, które trafia w dok³adnie tê sam± pozycjê, gdzie skoñczy³ ewentualny poprzedni m//g. Zapewnienie \G nie jest obs³ugiwane bez modyfikatora /g; obecnie bez /g, \G, zachowuje siê zupe³nie jak \A, lecz jest to przypadkowe i mo¿e siê w przysz³o¶ci zmieniæ.

Przyk³ady:

    # 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";

    # u¿ywanie 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 przyk³ad 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 skanerów w rodzaju lex jest /\G.../gc. Mo¿esz tak ³±czyæ ró¿ne rodzaje wyra¿eñ regularnych, maj±c tak mo¿liwo¶æ przetwarzania ³añcucha kawa³ek po kawa³ku, dokonuj±c ró¿nych akcji, zale¿nie od tego, które wyra¿enie zosta³o trafione. Ka¿de wyra¿enie próbuje trafiæ tam, gdzie poprzednie zakoñczy³o.

 $_ = <<'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 wyj¶cie (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/£AÑCUCH/

'£AÑCUCH'

Pojedynczo zacytowany ³añcuch literalny. Odwrotny uko¶nik oznacza odwrotny uko¶nik, chyba ¿e znajduje siê za nim ogranicznik lub inny odwrotny uko¶nik -- w tym wypadku odwrotny uko¶nik, lub ogranicznik jest interpolowany.

    $foo = q!I said, "You said, 'She said it.'"!;

    $bar = q('This is it.');

    $baz = '\n';                # ³añcuch dwuznakowy

qq/£AÑCUCH/

£AÑCUCH

£añcuch w podwójnych cudzys³owach, interpolowany.

    $_ .= qq

     (*** The previous line contains the naughty word "$1".\n)

                if /(tcl|rexx|python)/;      # :-)

    $baz = "\n";                # ³añcuch jednoznakowy

qx/£AÑCUCH/

`£AÑCUCH`

£añcuch, który jest interpolowany, a nastêpnie uruchamainay jako komenda systemowa. Zebrane standardowe wyj¶cie komendy jest zwracane. W kontek¶cie skalarnym, pojawia siê jako pojedynczy, wieloliniowy ³añcuch. W kontek¶cie listowym, jest rozdzielony na listê linii (jakkolwiek zdefiniowa³e¶ linie $/ lub $INPUT_RECORD_SEPARATOR).

    $today = qx{ date };

Zobacz sekcjê o operatorach I/O.

qw/£AÑCUCH/

Zwraca listê s³ów, wyci±gniêtych z ³añcucha przy u¿yciu osadzonych bia³ych spacji, jako ograniczników s³ów. Jest to równowa¿ne

    split(' ', q/£AÑCUCH/);

Pewne czêsto u¿ywane przyk³ady:

    use POSIX qw( setlocale localeconv )

    @EXPORT = qw( foo bar baz );

Czêstym b³êdem jest próba rozdzielania s³ów przecinkiem, lub wstwianie do wieloliniowych ³añcuchów qw komentarzy. W tej sytuacji, prze³±cznik -w daje ostrze¿enia je¶li ³añcuch zawiera znaki ``#''.

s/WZORZEC/ZAMIANA/egimosx

Szuka w ³añcuchu wzorca, a je¶li go znajdzie, to zamienia go tekstem zamiany i zwraca liczbê zamian. W przeciwnym wypadku zwraca fa³sz (specyficznie pusty ³añcuch).

Je¶li przez operator =~ lub !~ nie podano ³añcucha, u¿ywana jest zmienna $_. (£añcuch podany przez =~ musi byæ zmienn± skalarn±, elementem tablicy, tablicy asocjacyjnej, lub przypisaniem do jednego z nich, czyli lwarto¶ci±.)

Je¶li wybrany ogranicznik jest pojedynczym cudzys³owem, nie dokonywana jest interpolacja ani zmiennych WZORCA, ani ZAMIANY. W przeciwnym wypadku, je¶li WZORZEC zawiera $, który wygl±da bardziej jak zmienna, ni¿ test koñca ³añcucha, zmienna bêdzie interpolowana w czasie dzia³ania. Je¶li chcesz, by wzorzec by³ kompilowany tylko raz, za pierwsz± interpolacj± zmiennej, u¿yj opcji /o. Je¶li wzorzec jest analizowany jako ³añcuch null, uzywane jest zamiast tego ostatnie normalne wyra¿enie regularne. Zobacz jeszcze podrêcznik perlre(1). Zobacz te¿ perllocale(1), aby dowiedzieæ siê o wp³ywie use locale.

Opcje to:

    e   Analizuj praw± stronê jako wyra¿enie

    g   Zamieniaj globalnie

    i   Nie zwracaj uwagi na wielko¶æ liter

    m   Traktuj ³añcuch jak wiele linii

    o   Kompiluj wzorzec tylko raz

    s   Traktuj ³añcuch jako pojedyncz± liniê

    x   U¿yj rozszerzonych wyra¿eñ regularnych

Uko¶niki mog± byæ zamienione przez dowolny, niealfanumeryczny i niebia³ospacjowy ogranicznik. Je¶li u¿yte s± pojedyncze cudzys³owy, nie dokonywana jest interpretacja ³añcucha zamiany (modyfikator /e przeci±¿a to zachowanie). W przeciwnieñstwie do perla 4, perl 5 traktuje odwrotne cudzys³owy jako normalne ograniczniki; tekst zamiany nie jest wykonywany jako komenda. Je¶li WZORZEC jest rozdzielany cytatami nawiasowymi, ZAMIANA ma swoj± w³asn± parê cytatów, która mo¿e, lub nie, byæ cytatami nawiasowymi, np. s(foo)(bar) lub s<foo>/bar/. /e spowoduje, ¿e porcja zamiany zostanie zinterpretowana jako pe³ne perlowe wyra¿enie i zeval()owana zaraz potem. Jego sk³adnia jest jednak sprawdzania podczas kompilacji.

Przyk³ady:

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

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

    s/Login: $foo/Login: $bar/; # wzorzec czasu dzia³ania

    ($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 wyra¿enim, z /e

    s/^=(\w+)/&pod($1)/ge;      # u¿yj wywo³ania funkcji

    # /e mog± siê zagnie¿d¿aæ; to rozwinie

    # proste zmienne osadzone w $_

    s/(\$\w+)/$1/eeg;

    # Usuñ komentarze C

    $program =~ s {

        /\*     # Traf na rozdzielacz otwieraj±cy.

        .*?     # Traf w minimaln± liczbê znaków.

        \*/     # Traf w rozdzielacz zamykaj±cy.

    } []gsx;

    s/^\s*(.*?)\s*$/$1/;        # odetnij bia³± spacjê

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

Zauwa¿, ¿e w ostatnim przyk³adzie zamiast $ u¿yto \. W przeciwieñstwie do sed(1)a, u¿ywamy postaci \<cyfra> tylko po lewej stronie. Wszêdzie indziej, jest to $<cyfra>.

Czasami nie mo¿na u¿yæ po prostu /g, aby zasz³y wszystkie zmiany. Oto dwa popularne przypadki:

    # wstaw przecinki we w³a¶ciwych 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

T³umaczy wszystkie pojawienia siê znaków, znalezione w li¶cie szukania, na odpowiadaj±ce znaki z listy zamiany. Zwraca liczbê zamienionych, lub skasowanych znaków. Je¶li nie podano ³añcucha w operatorze =~ lub !~, u¿ywane jest $_. (£añcuch okre¶lony przez =~ musi byæ zmienn± skalarn±, elementem tablicy, elementem tablicy asocjacyjnej, lub przypisaniem do jednego z nich, czyli lwarto¶ci±). Dla mi³o¶ników edytora sed(1), udostêpniono synonim tr pod nazw± y. Je¶li LISTASZUKANIA jest rozdzielona nawiasami, to LISTAZAMIANY nie musi ich mieæ, np. tr[A-Z][a-z] lub tr(+-*/)/ABCD/.

Opcje:

    c   Dope³nij LISTÊSZUKANIA

    d   Kasuj znalezione, lecz niezamienione znaki

    s   Zmia¿d¿ zduplikowane zamienione znaki

Je¶li podany jest modyfikator /c, zbiór znaków z LISTYSZUKANIA jest dope³niany. Je¶li podany jest modyfikator /d, wszelkie znaki, podane w LI¦CIESZUKANIA, a nie znalezione w LI¦CIEZAMIANY s± kasowane. Je¶li podany jest modyfikator /s, to sekwencje, które zosta³y przet³umaczone do tego samego znaku s± mia¿d¿one do pojedynczej instancji tego znaku.

Je¶li u¿yty jest modyfikator /d, LISTAZAMIANY jest zawsze interpretowana tak, jak jest podana. W przeciwnym wypadku, gdy LISTAZAMIANY jest krótsza ni¿ LISTASZUKANIA, ostatni jej znak jest replikowany tak d³ugo, a¿ wype³ni brakuj±ce miejsca. Je¶li LISTAZAMIANY jest null, to replikowana jest LISTASZUKANIA. Jest to przydatne do zliczania znaków w klasie, lub dla mia¿d¿enia sekwencji znakowych klasy.

Przyk³ady:

    $ARGV[1] =~ tr/A-Z/a-z/;    # zmieñ na ma³e 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

Je¶li dla znaku podano wiele translacji, u¿ywana jest tylko pierwsza:

    tr/AAA/XYZ/

przet³umaczy A na X.

Zauwa¿, ¿e z uwagi na to, ¿e tablica translacji jest budowana w czasie kompilacji, ani LISTASZUKANIA, ani LISTAZAMIANY nie podlegaj± interpolacji cudzys³owowej. Znaczy to, ¿e je¶li chcesz u¿ywaæ zmiennych, musisz u¿yæ eval():

    eval "tr/$oldlist/$newlist/";

    die $@ if $@;

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

Operatory I/O

Istnieje wiele operatorów I/O (wej¶cia/wyj¶cia), o których powiniene¶ wiedzieæ. £añcuch ujêty w odwrotne cudzys³owy podlega najpierw podstawieniu zmiennych, podobnie jak ³añcuch ujêty w podwójne cudzys³owy. Nastêpnie jest interpretowany jako komenda, a jej wyj¶cie jest warto¶ci± pseudolitera³u, jak w pow³oce. W kontek¶cie skalarnym, zwracany jest pojedynczy ³añcuch, sk³±daj±cy siê z ca³ego wyj¶cia. W kontek¶cie listowym, zwracana jest lista warto¶ci dla ka¿dej linii wyj¶cia. (Mo¿na ustawiæ $/, co przeci±¿y domy¶lny terminator linii.) Komenda jest wykonywana przy ka¿dej analizie pseudolitera³u. Status komendy jest zwracany do $? (zobacz podrêcznik perlvar(1)). W przeciwieñstwie do csh(1), nie jest na danych zwracanych dokonywana translacja - nowe linie pozostaj± nowymi liniami. W przeciwieñstwie do wszelkich innych pow³ok, pojedyncze cudzys³owyu nie ukrywaj± nazw zmiennych w komendzie od interpretacji. Aby przekazaæ $ dalej, nale¿y go wycytowaæ odwrotnym uko¶nikiem. Ogóln± postaci± odwrotnych cudzys³owów jest qx//. (Poniewa¿ podlegaj± one zawsze równie¿ rozwiniêciu przez pow³okê, zobacz podrêcznik perlsec(1), który opisuje problemy bezpieczeñstwa.)

Analiza uchwytu pliku, który jest w nawiasach trójk±tnych, wyci±ga z pliku nastêpn± liniê, lub undef na jego koñcu. Normalnie, musisz zmiennej przypisaæ warto¶æ, lecz jest sytuacja, w której nastêpuje automatyczne przypisanie. Je¶li i TYLKO je¶li symbol wej¶cia jest jedyn± rzecz± wewn±trz warunku pêtli while lub for(;;), to warto¶æ jest przypisywana automatycznie zmiennej $_. Przypisana warto¶æ jest potem sprawdzana, by zobaczyæ czy jest zdefiniowane (Mo¿e siê to wydawaæ trochê dziwne, lecz bêdziesz u¿ywaæ tej konstrukcji w prawie ka¿dym swoim skrypcie perlowym.) Nastêpuj±ce linijki s± sobie równowa¿ne:

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

    while (<STDIN>) { print; }

    for (;<STDIN>;) { print; }

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

    print while <STDIN>;

Uchwyty plików STDIN, STDOUT i STDERR to uchwyty predefiniowane. Uchwyty stdin, stdout i stderr te¿ bêd± dzia³aæ, lecz nie w pakietach, w których s± interpretowane jako lokalne identyfikatory nie za¶ jako globalne.) Dodatkowe uchwyty plików mo¿na tworzyæ funkcj± open(). Zobacz jej opis w podrêczniku perlfunc(1).

Je¶li <UCHWYTPLIKU jest u¿ywany w kontek¶cie, oczekuj±cym listy, zwracana jest lista, sk³adaj±ca siê ze wszystkich linii wej¶ciowych, jedna linia na element listy. £atwo jest zaj±æ tak du¿y obszar danych, wiêc u¿ywaj tego ostro¿nie.

Zerowy uchwyt pliku <> jest specjalny i mo¿e byæ u¿ywany do emulacji zachowania edytora sed(1), lub awk(1). Wej¶cie z <> mo¿e nadchodziæ zarówno ze standardowego wej¶cia, lub z ka¿dego pliku, wymienionego w linii komend. Oto jak to dzia³a: za pierwsz± analiz± <>, sprawdzana jest tablica @ARGV i je¶li jest zerowa, $ARGV[0] jest ustawiane na ``-'', co oznacza po otwarciu standardowe wej¶cie. Tablica @ARGV jest nastêpnie przetwarzana jako lista nazw plików. Pêtla

    while (<>) {

        ...                     # kod dla ka¿dej linii

    }

jest równowa¿na nastêpuj±cemu pseudokodowi:

    unshift(@ARGV, '-') unless @ARGV;

    while ($ARGV = shift) {

        open(ARGV, $ARGV);

        while (<ARGV>) {

            ...         # kod dla ka¿dej linii

        }

    }

poza tym, ¿e jest trochê ³adniejsza i dzia³a. Naprawdê przesuwa tablicê @ARGV i wstawia bie¿±c± nazwê pliku do zmiennej $ARGV. U¿ywa te¿ wewnêtrznie uchwytu ARGV--<> jest po prostu synonimem <ARGV>, który jest magiczny. (Powy¿szy pseudokod nie dzia³a, gdy¿ traktuje ARGV amagicznie.)

Przed pierwszym <> mo¿esz modyfikowaæ @ARGV, o ile tablica bêdzie zawiera³a listê plików, których oczekujesz. Numey linii ($.) s± liczone tak, jakby wej¶cie by³o tylko jednym, szczê¶liwym plikiem. (Lecz zobacz przyk³ad z eof(), aby zobaczyæ jak zresetowaæ numery linii.)

Je¶li chcesz ustawiæ @ARGC na swoj± w³asn± listê plików, to nie ma sprawy. Je¶li chcesz przekazaæ do swojego skryptu prze³±czniki, mo¿esz u¿yæ jednego z modu³ów Getopts, lub wstawiæ na pocz±tku podobn± pêtlê:

    while ($_ = $ARGV[0], /^-/) {

        shift;

        last if /^--$/;

        if (/^-D(.*)/) { $debug = $1 }

        if (/^-v/)     { $verbose++  }

        ...             # inne prze³±czniki

    }

    while (<>) {

        ...             # kod dla ka¿dej linii

    }

Symbol <> zwraca FALSE tylko raz. Jesli wywo³asz go po tym, za³o¿y, ¿e przetwarzasz now± listê @ARGV i je¶li jej nie ustawi³e¶, pobierze wej¶cie ze STDIN.

Je¶li ³añcuch wewn±trz nawiasów trójk±tnych jest wskazaniem do zmiennej skalarnej (np. <$foo>), to zmienna ta przechowuje nazwê uchwytu, z którego pobierane jest wej¶cie. Np:

    $fh = \*STDIN;

    $line = <$fh>;

£añcuch w nawiasach trójk±tnych nie jest uchwytem pliku, to jest interpretowany jako wzorzec nazwy pliku do glob()owania i zwracana jest albo lista nazw pliku lub nastêpna nazwa pliku (zale¿nie od kontekstu). Najpierw dokonywany jest jeden poziom interpretacji $, lecz nie mo¿na powiedzieæ <$foo>, gdy¿ jest to niebezpo¶redni uchwyt pliku, opisany w poprzednim paragrafie. (W starszych wersjach perla, programi¶ci mogli wstawiaæ nawiasy do wymuszania interpretacji jako nazwy pliku do globowania: <${foo}>. Dzi¶ jednak, za czystsze uwa¿a siê bezpo¶rednie wo³anie funkcji wewnêtrznej -- glob($foo). Przyk³ad:

    while (<*.c>) {

        chmod 0644, $_;

    }

jest równowa¿ny

    open(FOO, "echo *.c | tr -s ' \t\r\f' '\\012\\012\\012\\012'|");

    while (<FOO>) {

        chop;

        chmod 0644, $_;

    }

W rzeczywisto¶ci, obecnie jest to w³a¶nie tak zaimplementowane. (Co znaczy, ¿e nie bêdzie dzia³aæ na nazwach plików ze spacjami, chyba ¿e masz u siebie csh(1).) Oczywi¶cie najkrótszym sposobem dokonania powy¿szego jest:

    chmod 0644, <*.c>;

Poniewa¿ globowanie u¿ywa pow³oki, czêsto szybciej jest wywo³aæ samodzielnie readdir() i dokonaæ grep()a na nazwach plików. Co wiêcej, z powodu obecnej implementacji, wywo³anie glob() mo¿e napotkaæ b³êdy w rodzaju ``Arg list too long'' (chyba ¿e zainstalowa³e¶ tcsh(1L) jako /bin/csh).

Glob analizuje swój (osadzony) argument tylko je¶li rozpoczyna now± listê. Wszystkie warto¶ci musz± byæ odczytane zanim znów rozpocznie. W kontek¶cie listowym nie jest to istotne, gdy¿ autmatycznie odczytujesz wszystkie. Jednak w kontek¶cie skalarnym, operator zwraca nastêpn± warto¶æ za ka¿dym wywo³aniem, lub FALSE na koñcu. Znowu, FALSE jest zwracane tylko raz. Je¶li wiêc oczekujesz od globa pojedynczej warto¶ci, to lepiej powiedzieæ

    ($file) = <blurch*>;

a nie

    $file = <blurch*>;

gdy¿ to drugie bêdzie rozró¿niaæ zwrócenie nazwy plików i zwrócenie FALSE.

Je¶li próbujesz dokonaæ interpolacji zmiennych, to zdecydowanie lepiej jest u¿yæ funkcji glob(), gdy¿ starsza notacja mo¿e spowodowaæ zak³opotanie u niektórych osób.

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

    @files = glob($files[$i]);

Zawijanie sta³ych

Podobnie jak C, perl posiada pewien zestaw analiz wyra¿eñ, wykonywanych podczas kompilacji -- dzieje siê to je¶li zauwa¿y, ¿e wszystkie argumenty operatora s± statyczne i nie maj± efektów ubocznych. W szczególno¶ci, np. konkatenacja litera³ów bez podstawieñ zmiennych jest dokonywana podczas kompilacji. Interpretacja odwrotnych uko¶ników nastêpuje równie¿ podczas kompilacji. Mo¿esz powiedzieæ

    'Now is the time for all' . "\n" .

        'good men to come to.'

a wszystko to wewnêtrznie zredukuje siê do jednego ³añcucha. Podobnie, je¶li powiesz

    foreach $file (@filenames) {

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

    }

to kompilator przeliczy liczby, które reprezentuje wyra¿enie.

Arytmetyka ca³kowita

Domy¶lnie, perl wykonuje wszystkie obliczenia zmiennoprzecinkowo. Jednak powiedzenie

    use integer;

mówi kompilatorowi, ¿e mo¿e u¿ywaæ odt±d, do koñca bloku operacji ca³kowitych. Wewnêtrzne bloki mog± temu zaprzeczyæ, mówi±c

    no integer;

co wystarcza do koñca ich bloku.

Operatory bitowe ("&'', ``|'', ``^'', ``~'', ``<<'', i ``>>") zawsze daj± wyniki ca³kowite. Jednak use integer ma wci±¿ dla nich znaczenie. Domy¶lnie ich wyniki s± interpretowane jako liczby ca³kowite bez znaku. Po w³±czeniu tej opcji, sa interpretowane ze znakiem. Np. ~0 normalnie jest analizowane do wielkiej warto¶ci ca³kowitej. Po use integer; ~0 staje siê -1.

Arytmetyka zmiennoprzecinkowa

Podczas gdy use integer daje arytmetykê ca³kowit±, nie ma podobnej instrukcji dla dawania zaokr±gleñ, lub odciêæ w konkretnych miejscach dziesiêtnych. Dla zaokr±gleñ do okre¶lonej ilo¶ci cyfr, najlepiej u¿yæ sprintf() lub printf().

Modu³ POSIX (czê¶æ standardowej dystrybucji perla) implementuje funkcje ceil(), floor() i kilka innych funkcji matematycznych i trygonometrycznych. Modu³ Math::Complex (równie¿ standardowy) definiuje sporo funkcji matematycznych, które mog± dzia³aæ równie¿ na liczbach rzeczywistych. Modu³ Math::Complex nie jest tak wydajny jak POSIX, lecz POSIX nie mo¿e dzia³aæ na liczbach zespolonych.

Zaokr±glanie w aplikacjach finansowych mo¿e mieæ powa¿ne konsekwencje i u¿ywana metoda powinna byæ podawana dok³adnie. W tych wypadkach, lepiej nie ufaæ temu, który system zaokr±glania jest u¿ywany przez perla, lecz zaimplementowaæ tak± funkcjê samodzielnie.