.rn '' }`
''' $RCSfile: perlop.1,v $$Revision: 1.7 $$Date: 2000/10/22 16:15:28 $
'''
''' $Log: perlop.1,v $
''' Revision 1.7  2000/10/22 16:15:28  wojtek2
''' wiodce (spacje, zera etc.)->pocztkowe
''' kontrolne (znaki, sekwencje)->sterujce
''' take "klawisze kontrolne" (Ctrl+klaw.)->klawisze sterujce
'''
''' Revision 1.6  1999/08/06 10:51:05  wojtek2
''' Pokuta: napis->acuch
''' rekursja->rekurencja
''' inne drobne
'''
''' Revision 1.5  1999/08/03 11:07:22  wojtek2
''' bistable->dwustanowy
''' przewaniei " xx rather than yy" -> "xx zamiast yy"
'''
''' Revision 1.4  1999/08/02 12:08:52  pborys
''' string->napis
''' shell->powoka
''' kernel->jdro
'''
''' Revision 1.3  1999/07/31 19:18:55  pborys
''' zmiana slashy na ukoniki
'''
''' Revision 1.2  1999/07/31 15:27:30  pborys
''' korekszkenz
'''
''' Revision 1.1  1999/07/31 12:04:58  pborys
''' slownik -- sownik, narazie niech bdzie w PTM, ew. pniej zrobi si
''' osobne repozytorium. Poddaj pod ew. dyskusj jego format itp. (pki jest
''' may :)
''' perlop.1 -- wersja beta, narazie skoczyem tumaczy, ale jeszcze nie
''' przegldaem, a od bdw pewnie si tam roi :(
'''
'''
.de Sh
.br
.if t .Sp
.ne 5
.PP
\fB\\$1\fR
.PP
..
.de Sp
.if t .sp .5v
.if n .sp
..
.de Ip
.br
.ie \\n(.$>=3 .ne \\$3
.el .ne 3
.IP "\\$1" \\$2
..
.de Vb
.ft CW
.nf
.ne \\$1
..
.de Ve
.ft R

.fi
..
'''
'''
'''     Set up \*(-- to give an unbreakable dash;
'''     string Tr holds user defined translation string.
'''     Bell System Logo is used as a dummy character.
'''
.tr \(*W-|\(bv\*(Tr
.ie n \{\
.ds -- \(*W-
.ds PI pi
.if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
.if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch
.ds L" ""
.ds R" ""
'''   \*(M", \*(S", \*(N" and \*(T" are the equivalent of
'''   \*(L" and \*(R", except that they are used on ".xx" lines,
'''   such as .IP and .SH, which do another additional levels of
'''   double-quote interpretation
.ds M" """
.ds S" """
.ds N" """""
.ds T" """""
.ds L' '
.ds R' '
.ds M' '
.ds S' '
.ds N' '
.ds T' '
'br\}
.el\{\
.ds -- \(em\|
.tr \*(Tr
.ds L" ``
.ds R" ''
.ds M" ``
.ds S" ''
.ds N" ``
.ds T" ''
.ds L' `
.ds R' '
.ds M' `
.ds S' '
.ds N' `
.ds T' '
.ds PI \(*p
'br\}
.\"	If the F register is turned on, we'll generate
.\"	index entries out stderr for the following things:
.\"		TH	Title 
.\"		SH	Header
.\"		Sh	Subsection 
.\"		Ip	Item
.\"		X<>	Xref  (embedded
.\"	Of course, you have to process the output yourself
.\"	in some meaninful fashion.
.if \nF \{
.de IX
.tm Index:\\$1\t\\n%\t"\\$2"
..
.nr % 0
.rr F
.\}
.TH PERLOP 1 "perl 5.004, patch 01" "7/Jun/97" "Podrcznik programisty perla"
.IX Title "PERLOP 1"
.UC
.IX Name "perlop - Perl operators and precedence"
.if n .hy 0
.if n .na
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
.de CQ          \" put $1 in typewriter font
.ft CW
'if n "\c
'if t \\&\\$1\c
'if n \\&\\$1\c
'if n \&"
\\&\\$2 \\$3 \\$4 \\$5 \\$6 \\$7
'.ft R
..
.\" @(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2
.	\" AM - accent mark definitions
.bd B 3
.	\" fudge factors for nroff and troff
.if n \{\
.	ds #H 0
.	ds #V .8m
.	ds #F .3m
.	ds #[ \f1
.	ds #] \fP
.\}
.if t \{\
.	ds #H ((1u-(\\\\n(.fu%2u))*.13m)
.	ds #V .6m
.	ds #F 0
.	ds #[ \&
.	ds #] \&
.\}
.	\" simple accents for nroff and troff
.if n \{\
.	ds ' \&
.	ds ` \&
.	ds ^ \&
.	ds , \&
.	ds ~ ~
.	ds ? ?
.	ds ! !
.	ds /
.	ds q
.\}
.if t \{\
.	ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
.	ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
.	ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
.	ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
.	ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
.	ds ? \s-2c\h'-\w'c'u*7/10'\u\h'\*(#H'\zi\d\s+2\h'\w'c'u*8/10'
.	ds ! \s-2\(or\s+2\h'-\w'\(or'u'\v'-.8m'.\v'.8m'
.	ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
.	ds q o\h'-\w'o'u*8/10'\s-4\v'.4m'\z\(*i\v'-.4m'\s+4\h'\w'o'u*8/10'
.\}
.	\" troff and (daisy-wheel) nroff accents
.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
.ds v \\k:\h'-(\\n(.wu*9/10-\*(#H)'\v'-\*(#V'\*(#[\s-4v\s0\v'\*(#V'\h'|\\n:u'\*(#]
.ds _ \\k:\h'-(\\n(.wu*9/10-\*(#H+(\*(#F*2/3))'\v'-.4m'\z\(hy\v'.4m'\h'|\\n:u'
.ds . \\k:\h'-(\\n(.wu*8/10)'\v'\*(#V*4/10'\z.\v'-\*(#V*4/10'\h'|\\n:u'
.ds 3 \*(#[\v'.2m'\s-2\&3\s0\v'-.2m'\*(#]
.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
.ds ae a\h'-(\w'a'u*4/10)'e
.ds Ae A\h'-(\w'A'u*4/10)'E
.ds oe o\h'-(\w'o'u*4/10)'e
.ds Oe O\h'-(\w'O'u*4/10)'E
.	\" corrections for vroff
.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
.	\" for low resolution devices (crt and lpr)
.if \n(.H>23 .if \n(.V>19 \
\{\
.	ds : e
.	ds 8 ss
.	ds v \h'-1'\o'\(aa\(ga'
.	ds _ \h'-1'^
.	ds . \h'-1'.
.	ds 3 3
.	ds o a
.	ds d- d\h'-1'\(ga
.	ds D- D\h'-1'\(hy
.	ds th \o'bp'
.	ds Th \o'LP'
.	ds ae ae
.	ds Ae AE
.	ds oe oe
.	ds Oe OE
.\}
.rm #[ #] #H #V #F C
.SH "NAZWA"
.IX Header "NAME"
perlop \- operatory perla i priorytety
.SH "STRESZCZENIE"
.IX Header "SYNOPSIS"
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.
(Uatwia to nauk perla programistom C.) Poza paroma wyjtkami, wszystkie
one operuj na wartociach skalarnych, nie tablicowych.
.PP
.Vb 24
\&    lewe        wyraenia i lewostronne operatory list
\&    lewe        ->
\&    niezwizane ++ --
\&    prawe       **
\&    prawe       ! ~ \e 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
.Ve
W nastpujcych sekcjach, operatory te s opisane w kolejnoci
priorytetowej.
.SH "OPIS"
.IX Header "DESCRIPTION"
.Sh "Wyraenia i lewostronne operatory list"
.IX Subsection "Terms and List Operators (Leftward)"
Wyraenie ma w perlu najwyszy priorytet. S to zmienne, cytaty,
operatory w rodzaju cytatw, dowolne wyraenie w nawiasach, i dowolna
funkcja, ktrej argumenty s umieszczone w nawiasach. W rzeczywistoci, w
perlu nie ma tak naprawd funkcji w oglnym sensie, s tylko operatory
listowe i operatory jednoargumentowe, zachowujce si jak funkcje, bo
ustawiasz wok nich nawiasy. S one opisane w podrczniku
\fIperlfunc\fR(1).
.PP
Jeli dowolny operator listowy (\fIprint()\fR itp.), lub dowolny operator
jednoargumentowy (\fIchdir()\fR) ma za sob lewy nawias, to operator i
argumenty z nawiasw s brane w najwyszym priorytecie, tak jak przy
normalnym wywoaniu funkcji.
.PP
Gdy nawiasy nie s podane, priorytet operatorw listowych w rodzaju
\f(CWprint\fR, \f(CWsort\fR, lub \f(CWchmod\fR 
jest albo bardzo wysoki, albo bardzo niski, zalenie od tego czy patrzysz na
lew stron, czy na praw stron operatora.
Na przykad w
.PP
.Vb 2
\&    @ary = (1, 3, sort 4, 2);
\&    print @ary;         # drukuje 1324
.Ve
przecinki po prawej stronie sort-a s analizowane przed sortowaniem, lecz
przecinki po lewej s analizowane pniej. Innymi sowy, operatory listowe
poeraj wszystkie argumenty, ktre za nimi nastpuj, a potem zachowuj si
jak proste wyraenie, szanujce wyraenie poprzedzajce.
Zauwa, e musisz by ostrony z nawiasami:
.PP
.Vb 3
\&    # Wykonuj exit przed drukowaniem:
\&    print($foo, exit);  # raczej nie to, czego chcesz
\&    print $foo, exit;   # ani to
.Ve
.Vb 4
\&    # Te drukuj przed wykonaniem exit
\&    (print $foo), exit; # To jest to czego chcesz
\&    print($foo), exit;  # to te
\&    print ($foo), exit; # nawet to
.Ve
Zauwa te, e
.PP
.Vb 1
\&    print ($foo & 255) + 1, "\en";
.Ve
Prawdopodobnie nie robi tego, co oczekujesz. Zobacz sekcj o nazwanych
operatorach jednoargumentowych.
.PP
Ponadto, jako wyraenia przetwarzane s te konstrukcje \f(CWdo {}\fR i
\f(CWeval {}\fR, a take wywoania podprocedur i metod, oraz anonimowe
konstruktory \f(CW[]\fR i \f(CW{}\fR.
.PP
Zobacz te sekcj o operatorach cytowania, a take sekcj o operatorach I/O.
.Sh "Operator strzaki"
.IX Subsection "The Arrow Operator"
Podobnie jak w C i \*(C+, \*(L"\f(CW->\fR\*(R" jest operatorem dereferencji.
Jeli prawa strona to element \f(CW[...]\fR lub \f(CW{...}\fR, to lewa
strona musi by tward, lub symboliczn referencj do tablicy, lub tablicy
asocjacyjnej (lub miejsca, ktre jest w stanie przechowywa tward
referencj, jeli jest to lwarto (przypisywalna)). Zobacz stron
\fIperlref\fR(1).
.PP
W przeciwnym wypadku, prawa strona jest nazw metody, lub prost zmienn
skalarn, zawierajc nazw metody, a lewa strona musi by albo obiektem
(pobogosawion przez bless referencj), lub nazw klasy (tj. nazw
pakietu).
Zobacz stron \fIperlobj\fR(1).
.Sh "Auto-inkrementacja i Auto-dekrementacja"
.IX Subsection "Auto-increment and Auto-decrement"
\*(L"++\*(R" i \*(L"--\*(R" dziaaj jak w C. To znaczy, jeli s
umieszczone przed zmienn, to inkrementuj lub dekrementuj zmienn przed
zwrceniem wartoci, a jeli s umieszczone za zmienn, to powoduj
inkrementacj lub dekrementacj po zwrceniu wartoci.
.PP
Operator auto-inkrementacji ma wbudowanych par dodatkowych rzeczy. Jeli
inkrementujesz zmienn, ktra jest numeryczna, lub ktra bya kiedykolwiek
uyta w kontekcie numerycznym, to uzyskasz normaln inkrementacj. Jednak
jeli zmienna bya uywana tylko w kontekstach acuchowych, a jej warto
nie jest nullem i odpowiada wzorcowi
\f(CW/^[a-zA-Z]*[0-9]*$/\fR, 
to inkrementacja jest dokonywana jak na acuchu, zachowujc kady znak w
zakresie, z przeniesieniem:
.PP
.Vb 4
\&    print ++($foo = '99');      # drukuje '100'
\&    print ++($foo = 'a0');      # drukuje 'a1'
\&    print ++($foo = 'Az');      # drukuje 'Ba'
\&    print ++($foo = 'zz');      # drukuje 'aaa'
.Ve
Operator autodekrementacji nie ma tych waciwoci.
.Sh "Potga"
.IX Subsection "Exponentiation"
Binarny \*(L"**\*(R" jest operatorem potgowania. Zauwa, e czy mocniej
ni jednoargumentowy minus, wic \-2**4 to \-(2**4), a nie (\-2)**4. 
(Jest to zaimplementowane przy uyciu funkcji
\fIpow\fR\|(3) z C, ktra w rzeczywistoci dziaa na liczbach typu podwjnej
precyzji.)
.Sh "Symboliczne operatory jednoargumentowe"
.IX Subsection "Symbolic Unary Operators"
Jednoargumentowy \*(L"!\*(R" 
wykonuje negacj logiczn, czyli \*(L"not\*(R".  
Zobacz te \f(CWnot\fR dla wersji o niszym priorytecie.
.PP
Jednoargumentowy \*(L"\-\*(R" dokonuje arytmetycznej negacji na numerycznym
operandzie. Jeli operand jest identyfikatorem, zwracany jest acuch
skadajcy si ze znaku minus i z identyfikatora.
W przeciwnym wypadku, jeli acuch rozpoczyna si
znakiem plus lub minus, zwracany jest acuch z przeciwnym znakiem. Jednym z
efektw tego dziaania jest to, e \f(CW-bareword\fR jest rwnowane
\f(CW"-bareword"\fR.
.PP
Jednoargumentowy \*(L"~\*(R" dokonuje negacji bitowej.
(Zobacz te sekcj o arytmetyce cakowitej.)
.PP
Jednoargumentowy \*(L"+\*(R" 
nie daje adnego efektu, nawet na acuchach. Jest przydatny do rozdzielania
nazwy funkcji od otoczonego nawiasami wyraenia, ktre w przeciwnym wypadku
byoby interpretowane jako cakowita lista argumentw funkcji. (Zobacz
przykady w sekcji o wyraeniach i lewostronnych operatorach listowych.)
.PP
Jednoargumentowy \*(L"\e\*(R" tworzy referencj do tego, co po nim
nastpuje. Zobacz podrcznik \fIperlref\fR(1).
Nie myl tego zachowania z zachowaniem w acuchu odwrotnego ukonika, cho obie
postacie maj t sam waciwo chronienia nastpnej rzeczy od
interpretacji.
.Sh "Operatory czenia"
.IX Subsection "Binding Operators"
Binarny \*(L"=~\*(R" czy wyraenie skalarne z obsug wyraenia
regularnego. 
Pewne operacje domylnie szukaj lub zmieniaj acuch \f(CW$_\fR.
Operator ten powoduje, e taka operacja dziaa na innym acuchu. Prawy
argument jest wzorcem przeszukiwania, podstawienia lub translacji. Lewy
argument jest przeszukiwanym acuchem, zamiast domylnego \f(CW$_\fR.
Warto zwracana okrela sukces operacji. (Jeli prawy argument jest raczej
wyraeniem ni wzorcem przeszukiwania, podstawiania lub translacji, to jest
interpretowany jako wzorzec przeszukiwania czasu dziaania. Moe to by
mniej efektywne ni jawne szukanie, gdy wzorzec musi by za kadym razem
kompilowany. 
.PP
[Przyp. tum: Na przykad "$lancuch="bla"; $lancuch=~s/l/q/; print $lancuch" da w
wyniku acuch "bqa".]
.PP
Binarny \*(L"!~\*(R" jest podobny do \*(L"=~\*(R" lecz warto zwracana jest
logicznie negowana.
.Sh "Operatory mnoenia"
.IX Subsection "Multiplicative Operators"
Binarny \*(L"*\*(R" mnoy dwie liczby.
.PP
Binarny \*(L"/\*(R" dzieli dwie liczby.
.PP
Binarny \*(L"%\*(R" oblicza reszt (modulo) z dwch liczb. Z cakowitymi
operandami \f(CW$a\fR i \f(CW$b\fR: jeli \f(CW$b\fR jest dodatnie, to
\f(CW$a % $b\fR to \f(CW$a\fR minus najwiksza wielokrotno \f(CW$b\fR,
ktra nie jest wiksza od
\f(CW$a\fR.  Jeli \f(CW$b\fR jest ujemne, to \f(CW$a % $b\fR to \f(CW$a\fR 
minus najmniejsza wielokrotno \f(CW$b\fR, ktra nie jest mniejsza ni
\f(CW$a\fR (np. wynik bdzie mniejszy lub rwny od zera).
.PP
Binarny \*(L"x\*(R" jest operatorem powtrzenia.
W kontekcie skalarnym, zwraca acuch skadajcy si z lewego operanda,
powtrzonego tyle razy, ile podano w prawym. W kontekcie listowym, jeli
lewy operand jest list w nawiasach, powtarzana jest lista.
.PP
.Vb 1
\&    print '-' x 80;             # wydrukuj wiersz kresek
.Ve
.Vb 1
\&    print "\et" x ($tab/8), ' ' x ($tab%8);      # tabuluj poprzez
.Ve
.Vb 2
\&    @ones = (1) x 80;           # lista 80 jedynek
\&    @ones = (5) x @ones;        # ustaw wszystkie elementy na 5
.Ve
.Sh "Operatory dodawania"
.IX Subsection "Additive Operators"
Binarny \*(L"+\*(R" zwraca sum dwch liczb.
.PP
Binarny \*(L"\-\*(R" zwraca rnic dwch liczb.
.PP
Binarny \*(L".\*(R" czy (konkatenuje) acuchy.
.Sh "Operatory przesuwania"
.IX Subsection "Shift Operators"
Binanry \*(L"<<\*(R" zwraca warto swojego lewego argumentu, przesunitego
w lewo o ilo bitw, podan w prawym argumencie. Argumenty powinny by
liczbami cakowitymi. (Zobacz te sekcj o arytmetyce cakowitej.)
.PP
Binarny \*(L">>\*(R" zwraca warto swojego lewego argumentu, przesunitego
w prawo o ilo bitw, podan w prawym argumencie. Argumenty powinny by
liczbami cakowitymi.
.Sh "Nazwane operatory jednoargumentowe"
.IX Subsection "Named Unary Operators"
Rne nazwane operatory jednoargumentowe s traktowane jak jednoargumentowe
funkcje, z opcjonalnymi nawiasami. S to m.in testy plikowe, itp. Zobacz
podrcznik \fIperlfunc\fR(1).
.PP
Jeli za dowolnym operatorem listowym (\fIprint()\fR itp.), lub operatorem
jednoargumentowym (\fIchdir()\fR itp.) nastpuje lewy nawias, to operator i
argumenty w nawiasach s brane z najwyszym priorytetem, tak jak przy
wywoaniu funkcji. Przykady:
.PP
.Vb 4
\&    chdir $foo    || die;       # (chdir $foo) || die
\&    chdir($foo)   || die;       # (chdir $foo) || die
\&    chdir ($foo)  || die;       # (chdir $foo) || die
\&    chdir +($foo) || die;       # (chdir $foo) || die
.Ve
lecz poniewa * ma wyszy priorytet ni ||:
.PP
.Vb 4
\&    chdir $foo * 20;    # chdir ($foo * 20)
\&    chdir($foo) * 20;   # (chdir $foo) * 20
\&    chdir ($foo) * 20;  # (chdir $foo) * 20
\&    chdir +($foo) * 20; # chdir ($foo * 20)
.Ve
.Vb 4
\&    rand 10 * 20;       # rand (10 * 20)
\&    rand(10) * 20;      # (rand 10) * 20
\&    rand (10) * 20;     # (rand 10) * 20
\&    rand +(10) * 20;    # rand (10 * 20)
.Ve
Zobacz te sekcj o wyraeniach i lewostronnych operatorach listowych.
.Sh "Operatory relacji"
.IX Subsection "Relational Operators"
Binarny \*(L"<\*(R" zwraca prawd, jeli lewy argument jest numerycznie
mniejszy ni prawy.
.PP
Binarny \*(L">\*(R" zwraca prawd, jeli lewy argument jest numerycznie
wikszy ni prawy.
.PP
Binarny \*(L"<=\*(R" zwraca prawd, jeli lewy argument jest numerycznie
mniejszy lub rwny prawemu.
.PP
Binarny \*(L">=\*(R" zwraca prawd, jeli lewy argument jest numerycznie
wikszy lub rwny prawemu.
.PP
Binarny \*(L"lt\*(R" zwraca prawd, jeli lewy argument jest acuchowo
mniejszy od prawego.
.PP
Binarny \*(L"gt\*(R" zwraca prawd, jeli lewy argument jest acuchowo
wikszy od prawego.
.PP
Binarny \*(L"le\*(R" zwraca prawd, jeli lewy argument jest acuchowo
mniejszy lub rwny prawemu.
.PP
Binarny \*(L"ge\*(R" zwraca prawd, jeli lewy argument jest acuchowo
wikszy lub rwny prawemu.
.Sh "Operatory rwnoci"
.IX Subsection "Equality Operators"
Binarny \*(L"==\*(R" zwraca prawd, jeli lewy argument jest numerycznie
rwny prawemu.
.PP
Binarny \*(L"!=\*(R" zwraca prawd, jeli lewy argument nie jest numerycznie
rwny prawemu.
.PP
Binarny \*(L"<=>\*(R" zwraca \-1, 0, lub 1, zalenie od tego czy lewy
argument jest numerycznie mniejszy, rwny, lub wikszy od prawego.
.PP
Binarny \*(L"eq\*(R" zwraca prawd, jeli lewy argument jest acuchowo rwny
prawemu.
.PP
Binarny \*(L"ne\*(R" zwraca prawd, jeli lewy argument nie jest acuchowo
rwny prawemu.
.PP
Binarny \*(L"cmp\*(R" zwraca \-1, 0, lub 1, zalenie od tego, czy lewy
argument jest acuchowo mniejszy, rwny, lub wikszy od prawego.
.PP
\*(L"lt\*(R", \*(L"le\*(R", \*(L"ge\*(R", \*(L"gt\*(R" i \*(L"cmp\*(R" 
mog uywa kolejnoci sortowania, okrelonej przez biece locale (gdy
uyte jest \f(CWuse locale\fR). Zobacz podrcznik \fIperllocale\fR(1).
.Sh "Bitowy And"
.IX Subsection "Bitwise And"
Binarny \*(L"&\*(R" zwraca jego operatory, poczone bitowo operacj logiczn 
AND.
(Zobacz te sekcj o arytmetyce cakowitej.)
.Sh "Bitowy Or i Xor (eXclusive Or)"
.IX Subsection "Bitwise Or and Exclusive Or"
Binarny \*(L"|\*(R" zwraca swoje operatory, poczone bitowo operacj
logiczn OR. (Zobacz te sekcj o arytmetyce cakowitej).
.PP
Binarny \*(L"^\*(R" zwraca swoje operatory, poczone bitowo operacj XOR.
(Zobacz te sekcj o arytmetyce cakowitej.)
.Sh "Logiczny And w stylu C"
.IX Subsection "C\-style Logical And"
Binarny \*(L"&&\*(R" dokonuje logicznej operacji AND. Jeli lewy operand
jest faszywy (false), to prawy nie jest nawet analizowany. Kontekst
skalarny, lub listowy propaguje do prawego operatora, jeli jest on
analizowany.
.Sh "Logiczny Or w stylu C"
.IX Subsection "C\-style Logical Or"
Binarny \*(L"||\*(R" 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.
.PP
Operatory \f(CW||\fR i \f(CW&&\fR rni si od C tym, e zwracaj ostatni
analizowan warto zamiast 0 czy 1. Tak wic przenonym sposobem
znalezienia katalogu domowego (zakadajc, e nie jest \*(L"0"), moe by:
.PP
.Vb 2
\&    $home = $ENV{'HOME'} || $ENV{'LOGDIR'} ||
\&        (getpwuid($<))[7] || die "You're homeless!\en";
.Ve
Jako czytelniejsze alternatywy \f(CW&&\fR i \f(CW||\fR, 
perl udostpnia operatory \*(L"and\*(R" i \*(L"or\*(R" (patrz niej).
Zachowanie jest identyczne. Jednak ich priorytet jest niszy, wic moesz
ich bezpiecznie uywa po operatorze listowym, bez koniecznoci uywania
nawiasw:
.PP
.Vb 2
\&    unlink "alpha", "beta", "gamma"
\&            or gripe(), next LINE;
.Ve
Z uyciem operatorw w stylu C, trzeba by byo to zapisa jako:
.PP
.Vb 2
\&    unlink("alpha", "beta", "gamma")
\&            || (gripe(), next LINE);
.Ve
.Sh "Operator zakresu"
.IX Subsection "Range Operator"
Binarny \*(L"..\*(R" jest operatorem zakresu, ktry 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 \f(CWfor (1..10)\fR 
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:
.PP
.Vb 3
\&    for (1 .. 1_000_000) {
\&        # kod
\&    }
.Ve
W kontekcie skalarnym, \*(L"..\*(R" zwraca warto logiczn. Operator jest
dwustanowy, jak flip-flop i emuluje operator zakresu liniowego (przecinek) z
\fBsed\fR(1), \fBawk\fR(1) i rnych edytorw. Kady operator \*(L"..\*(R"
obsuguje swj wasny stan logiczny. Jest on faszywy tak dugo, jak dugo
lewy operand jest faszywy. Gdy lewy operand stanie si prawdziwy, operator
zakresu pozostaje prawdziwy dopki prawy argument jest prawd, PO czym,
operator zakresu przyjmuje warto faszu. (Nie staje si faszywym do
czasu nastpnej jego analizy. Moe testowa prawy operand i sta si
faszywym w tej samej analizie, kiedy sta si prawdziwym (jak w
\fBawk\fR(1)), lecz wci bdzie raz zwraca prawd. Jeli nie chcesz by
testowa prawy operand przed nastpn analiz (jak w \fBsed\fR(1)), uyj
trzech kropek (\*(R"...") zamiast dwch.) Prawy operand nie jest analizowany
podczas gdy operator jest w stanie faszu, a lewy operand nie jest
analizowany gdy operator jest w stanie prawdy. Priorytet jest troch niszy
ni || i &&. Zwracana warto jest albo acuchem null dla faszu, lub
liczb sekwencyjn (zaczynajc si od 1) dla prawdy. Liczba sekwencyjna
jest resetowana dla kadego napotkanego zakresu. Kocowa liczba
sekwencyjna w zakresie ma doklejony acuch \*(L"E0\*R", ktry nie ma jednak
wpywu na warto numeryczn, a za to daje co, czego moesz oczekiwa na
kocu. Moesz wyczy punkt pocztkowy przez oczekiwanie a liczba
sekwencyjna stanie si wiksza ni jeden. Jeli ktry z operandw
skalarnego \*(L"..\*(R" jest literaem numerycznym, operand jest niejawnie
porwnywany ze zmienn \f(CW$.\fR, biecym numerem linii.
Przykady
.PP
Jako operator skalarny:
.PP
.Vb 3
\&    if (101 .. 200) { print; }  # wydrukuj drug setk linii
\&    next line if (1 .. /^$/);   # pomi linie nagwka [pocztowego]
\&    s/^/> / if (/^$/ .. eof()); # Cytuj ciao
.Ve
Jako operator listowy:
.PP
.Vb 3
\&    for (101 .. 200) { print; } # drukuj 100 razy $_ 100
\&    @foo = @foo[0 .. $#foo];    # kosztowny no-op
\&    @foo = @foo[$#foo-4 .. $#foo];      # wytnij ostatnich 5 elementw
.Ve
Operator zakresu (w kontekcie listowym) uywa w wypadku gdy operandy s
acuchami magicznego algorytmu autoinkrementacji. Moesz powiedzie
.PP
.Vb 1
\&    @alphabet = ('A' .. 'Z');
.Ve
i uzyska tak wszystkie litery alfabetu, lub
.PP
.Vb 1
\&    $hexdigit = (0 .. 9, 'a' .. 'f')[$num & 15];
.Ve
by uzyska liczby szesnastkowe, lub
.PP
.Vb 1
\&    @z2 = ('01' .. '31');  print $z2[$mday];
.Ve
by uzyska daty z pocztkowymi zerami. Jeli ostatnia podana warto nie
jest w sekwencji, ktr daje magiczna inkrementacja, to sekwencja idzie tak
daleko, a nastpna warto nie bdzie dusza ni podana ostatnia warto.
.Sh "Operator warunkowy"
.IX Subsection "Conditional Operator"
\*(L"?:\*(R" jest operatorem warunkowym, zupenie jak w C. Dziaa podobnie
do konstrukcji if-then-else. Jeli argument przed ? jest prawdziwy, to
zwracany jest argument przed :. W przeciwnym wypadku, zwracany jest argument
po :. Na przykad:
.PP
.Vb 2
\&    printf "Mam %d ps%s.\en", $n,
\&            ($n == 1) ? "a" : "y";
.Ve
Kontekst skalarny, lub listowy propaguje do 2-giego lub 3-ciego argumentu,
zalenie od wyboru.
.PP
.Vb 3
\&    $a = $ok ? $b : $c;  # we skalar
\&    @a = $ok ? @b : @c;  # we tablic
\&    $a = $ok ? @b : @c;  # oops, to tylko licznik!
.Ve
Operator moe by przypisany jeli obydwa argumenty -- 2-gi i 3-ci s
legalnymi lwartociami (co znaczy e mona do nich przypisa):
.PP
.Vb 1
\&    ($a_or_b ? $a : $b) = $c;
.Ve
Niekoniecznie musi to jednak poprawi czytelno twojego programu.
.Sh "Operatory przypisania"
.IX Subsection "Assignment Operators"
\*(L"=\*(R" jest zwykym operatorem przypisania.
.PP
Operator przypisania dziaa jak w C. Tzn,
.PP
.Vb 1
\&    $a += 2;
.Ve
jest rwnowane
.PP
.Vb 1
\&    $a = $a + 2;
.Ve
cho bez powielania efektw ubocznych, ktre moe pociga za sob
dereferencja lwartoci, tak jak dla \fItie()\fR. Inne operatory
przypisania dziaaj podobnie. Rozpoznawane s nastpujce:
.PP
.Vb 4
\&    **=    +=    *=    &=    <<=    &&=
\&           -=    /=    |=    >>=    ||=
\&           .=    %=    ^=
\&                 x=
.Ve
Zauwa, e podczas gdy s one zgrupowane w rodziny, maj jednakowy priorytet
przypisania.
.PP
W przeciwiestwie do C, operator przypisania daje prawidow lwarto.
Modyfikowanie przypisania jest rwnowane do robienia przypisania, a potem
zmieniania przypisanej zmiennej. jest to przydatne do modyfikowania kopii
czego, np:
.PP
.Vb 1
\&    ($tmp = $global) =~ tr [A-Z] [a-z];
.Ve
Podobnie,
.PP
.Vb 1
\&    ($a += 2) *= 3;
.Ve
jest rwnowane
.PP
.Vb 2
\&    $a += 2;
\&    $a *= 3;
.Ve
.Sh "Operator przecinka"
.IX Subsection "Comma Operator"
Binarny \*(L",\*(R" jest operatorem przecinka. W kontekcie skalarnym
analizuje swj lewy argument, wyrzuca jego warto i nastpnie analizuje
prawy argument, zwracajc jego warto. Jest to takie samo, jak operator
przecinka z C.
.PP
W kontekcie listowym, jest to po prostu separator listy i wstawia obydwa
argumenty do listy.
.PP
Znak => jest czsto synonimem operatora przecinka. Przydatny jest
do dokumentowania argumentw, ktre s w parach. Od wersji 5.001 wymusza to
te interpretacj kadego sowa z lewej jako acucha.
.Sh "Operatory listowe (w prawo)"
.IX Subsection "List Operators (Rightward)"
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
\*(L"and\*(R", \*(L"or\*(R", i \*(L"not\*(R", ktre mog by uywane do
analizowania wywoa do operatorw listowych, bez potrzeby dodatkowych
nawiasw:
.PP
.Vb 2
\&    open HANDLE, "filename"
\&        or die "Can't open: $!\en";
.Ve
Zobacz te dyskusj operatorw listowych w sekcji o wyraeniach i
operatorach listowych lewostronnych.
.Sh "Logiczny Not"
.IX Subsection "Logical Not"
Jednoargumentowy \*(L"not\*(R" zwraca logiczn negacj prawego argumentu.
Jest rwnowany \*(L"!\*(R", lecz ma niszy priorytet.
.Sh "Logiczny And"
.IX Subsection "Logical And"
Binarny \*(L"and\*(R" zwraca logiczn koniunkcj otaczajcych wyrae. Jest
rwnowany &&, lecz ma niszy priorytet. Znaczy to, e prawe wyraenie jest
analizowane tylko jeli lewe jest prawdziwe.
.Sh "Logiczny or i xor"
.IX Subsection "Logical or and Exclusive Or"
Binarny \*(L"or\*(R" zwraca logiczn dyzjunkcj otaczajcych wyrae. Jest
rwnowany ||, lecz ma niszy priorytet. Znaczy to, e prawe wyraenie jest
wykonywane tylko jeli lewe jest faszywe.
.PP
Binarny \*(L"xor\*(R" zwraca \s-1XOR\s0 otaczajcych wyrae.
Nie moe by oczywicie uywany z zaweniem, jak or.
.Sh "Operatory C, ktrych brakuje w perlu"
.IX Subsection "C Operators Missing From Perl"
Oto operatory C, ktrych perl nie posiada:
.Ip "jednoargumentowy &" 8
.IX Item "unary &"
Operator adresu. (Lecz zobacz opis operatora \*(L"\e\*(R".)
.Ip "jednoargumentowy *" 8
.IX Item "unary *"
Operator dereferencji (wyuskania) adresu. (Perlowe przedrostkowe operatory
dereferencji to: $, @, %, &.)
.Ip "(\s-1TYP\s0)" 8
.IX Item "(\s-1TYPE\s0)"
Operator konwersji typw.
.Sh "Operatory cytatw i cytatopodobne"
.IX Subsection "Quote and Quote-like Operators"
Podczas gdy normalnie mylimy o cytatach jak o literalnych wartociach,
w perlu maj one funkcj operatorw, dajc rne waciwoci interpolowania i
porwnywania wzorcw.
Perl daje dla tych zachowa tradycyjne znaki cytowania, lecz rwnie sposb
na wybieranie znaku cytowania. W nastpujcej tablicy, \f(CW{}\fR 
oznacza par ogranicznikw, ktre wybierzesz. Ograniczniki nienawiasowe uywaj
tego samego znaku na pocztek i koniec, ale 4 rodzaje nawiasw mog si
zagnieda.
.PP
.Vb 8
\&    Zwyczajowy Standardowy Znaczenie    Interpoluje
\&        ''       q{}       Litera         nie
\&        ""      qq{}       Litera         tak
\&        ``      qx{}       Komenda         tak
\&                qw{}      Lista sw       nie
\&        //       m{} Porwnanie ze wzorcem tak
\&                 s{}{}   Podstawienie      tak
\&                tr{}{}   Translacja        nie
.Ve
Dla konstrukcji, wykonujcych interpolacj, zmienne zaczynajce si od \*(L"\f(CW$\fR\*(R" 
lub \*(L"\f(CW@\fR\*(R" s interpolowane jako nastpujce sekwencje:
.PP
.Vb 16
\&    \et          tab             (HT, TAB)
\&    \en          nowalinia       (LF, NL)
\&    \er          return          (CR)
\&    \ef          form feed       (FF)
\&    \eb          backspace       (BS)
\&    \ea          alarm (dzwonek) (BEL)
\&    \ee          escape          (ESC)
\&    \e033        znak semkowy
\&    \ex1b        znak szesnastkowy
\&    \ec[         znak sterujcy
\&    \el          zmie nastpny znak na ma liter
\&    \eu          zmie nastpny znak na du liter
\&    \eL          zmie na ma liter a do \eE
\&    \eU          zmie na du liter a do \eE
\&    \eE          koniec modyfikacji rozmiaru
\&    \eQ          cytuj metaznaki regexp a do \eE
.Ve
Jeli uywane jest \f(CWuse locale\fR, mapa rozmiarw liter odpowiada
lokalnej sytuacji. Zobacz podrcznik \fIperllocale\fR(1).
.PP
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 wczane do wzorca ze zmiennych. Jeli
tego nie chcesz, uyj \f(CW\eQ\fR.
.PP
Poza powyszym, nie ma wielokrotnych poziomw interpolacji. W
rzeczywistoci, w przeciwiestwie do oczekiwa programistw powokowych,
odwrotne cudzysowy nie interpoluj w podwjnych cudzysowach, a pojedyncze
otoczone w podwjnych cudzysowach nie utrudniaj analizy zmiennych w nich 
zawartych.
.Sh "Operatory cytatopodobne Regexp"
.IX Subsection "Regexp Quote-Like Operators"
Oto cytatopodobne operatory, ktre dotycz si dziaa zwizanych z
porwnywaniem wzorcw.
.Ip "?\s-1WZORZEC\s0?" 8
.IX Item "?\s-1PATTERN\s0?"
Jest to co w rodzaju przeszukiwania \f(CW/wzorzec/\fR,
lecz midzy wywoaniami operatora \fIreset()\fR, trafienie jest jednokrotne.
Jest to przydatna optymalizacja, jeli np. chcesz zobaczy tylko pierwsze
pojawienie si czego w pliku, lub zbiorze.
Resetowane s tylko wzorce \f(CW??\fR, lokalne dla biecego pakietu.
.Sp
To uycie jest niezalecane i moe by usunite w przyszych wersjach perla.
.Ip "m/\s-1WZORZEC/\s0gimosx" 8
.IX Item "m/\s-1PATTERN/\s0gimosx"
.Ip "/\s-1WZORZEC/\s0gimosx" 8
.IX Item "/\s-1PATTERN/\s0gimosx"
Przeszukuje wzorzec dla trafienia i w kontekcie skalarnym wzraca prawd (1), 
lub fasz (''). Jeli nie podano adnego acucha poprzez operator \f(CW=~\fR,
lub \f(CW!~\fR, przeszukiwany jest acuch \f(CW$_\fR.  
(acuch podany przez
\f(CW=~\fR nie musi by lwartoci \*(-- moe by wynikiem analizy wyraenia,
lecz pamitaj, e \f(CW=~\fR wie do mocno.) Zobacz te podrcznik
\fIperlre\fR(1).
Zobacz podrcznik \fIperllocale\fR(1) dla dyskusji o dodatkowych sprawach,
zwizanych z uyciem \f(CWuse locale\fR.
.Sp
Opcje to:
.Sp
.Vb 6
\&    g   Porwnuj globalnie, na wszystkich pojawieniach
\&    i   Porwnuj bez zwracania uwagi na wielko liter
\&    m   Traktuj acuch jako wielokrotne linie
\&    o   Kompiluj wzorzec tylko raz
\&    s   Traktuj acuch jako pojedyncz lini
\&    x   Uyj rozszerzonych wyrae regularnych
.Ve
Jeli ogranicznikiem jest \*(L"/\*(R", to pocztkowe \f(CWm\fR jest opcjonalne.  
Uywajc \f(CWm\fR, moesz wykorzysta jako ograniczniki dowoln par
nialfanumerycznych, niebiaospacjowych znakw. Jest to przydatne do
porwnywania unixowych nazw cieek, ktre mog zawiera \*(L"/\*(R".
Zapobiega to \s-1LTS\s0 (syndrom wskiej wykaaczki).  Jeli \*(L"?\*(R" 
jest ogranicznikiem, to stosowana jest regua trafienia-tylko-raz instrukcji
\f(CW?WZORZEC?\fR.
.Sp
\s-1WZORZEC\s0 moe zawiera zmienne, ktre bd interpolowane (a wzorzec
rekompilowany) za kad analiz. (Zauwa, e \f(CW$)\fR i \f(CW$|\fR 
mog nie by interpolowane, gdy wygldaj jak testy koca acucha.)
Jeli chcesz, by takie wzorce byy kompilowane tylko raz, dodaj do
ostatniego ogranicznika znak \f(CW/o\fR. Zapobiega to kosztownej kompilacji
czasu dziaania i jest przydatne, gdy warto, z ktrej korzystasz nie
zmienia si w czasie ycia skryptu. Jednak pamitaj, e opcja
\f(CW/o\fR daje obietnic, i nie zmienisz zmiennych ze wzorca.
Jeli je zmienisz, perl tego nie zauway.
.Sp
Jeli \s-1WZORZEC\s0 zostanie zanalizowany jako acuch null, to uyte
zostanie ostatnie wykonane wyraenie regularne.
.Sp
W kontekcie, wymagajcym wartoci listowej, porwnanie wzorca zwraca list,
skadajc si z listy podwyrae, trafionych przez nawiasy z wzorca, np.
(\f(CW$1\fR, \f(CW$2\fR, \f(CW$3\fR...).  
(Zauwa, e ustawione tu s rwnie \f(CW$1\fR itp. i e rni si to od
zachowania perla 4.) Jeli porwnanie si nie powiedzie, zwracana jest
tablica null. Jeli porwnanie si powiedzie, lecz nie bdzie nawiasw,
zwracana zostanie warto listowa (1).
.Sp
Przykady:
.Sp
.Vb 2
\&    open(TTY, '/dev/tty');
\&    <TTY> =~ /^y/i && foo();    # zrb foo, jeli trzeba
.Ve
.Vb 1
\&    if (/Version: *([0-9.]*)/) { $version = $1; }
.Ve
.Vb 1
\&    next if m#^/usr/spool/uucp#;
.Ve
.Vb 5
\&    # grep biedaka
\&    $arg = shift;
\&    while (<>) {
\&        print if /$arg/o;       # kompiluj tylko raz
\&    }
.Ve
.Vb 1
\&    if (($F1, $F2, $Etc) = ($foo =~ /^(\eS+)\es+(\eS+)\es*(.*)/))
.Ve
Ostatni przykad dzieli \f(CW$foo\fR na pierwsze dwa sowa i reszt linii.
Przypisuje te trzy pola do \f(CW$F1\fR, \f(CW$F2\fR i \f(CW$Etc\fR.  
Warunek jest prawdziwy, jeli przypisane zostay wartoci ktrejkolwiek ze
zmiennych, czyli jeli wzorzec zosta trafiony.
.Sp
Modyfikator \f(CW/g\fR okrela globalne porwnywanie wzorcw \*(-- tj. takie,
gdzie trafie jest tyle ile si da w danym acuchu. Zachowanie tego zaley
od kontektu -- w listowym zwracana jest lista wszystkich podacuchw,
trafionych przez wszystkie nawaisy wyraenia regularnego.
Jeli nie byo nawiasw, zwracana jest lista trafionych acuchw, tak jakby
byy nawiasy wok caego wzorca.
.Sp
W kontekcie skalarnym, \f(CW,//g\fR iteruje poprzez acuch, zwracajc
\s-1TRUE\s0 za kadym trafieniem i \s-1FALSE\s0 przy braku trafienia.
(Innymi sowy, zapamituje ostatni pozycj i restartuje od tego miejsca.
Moesz znale biec pozycj trafienia przy uyciu funkcji \fIpos()\fR;
zobacz jej opis w podrczniku \fIperlfunc\fR(1).)
Brak trafienia normalnie resetuje pozycj przeszukiwania na pocztek
acucha, lecz moesz temu zapobiec, dodajc modyfikator \*(L"c\*(R"
(np. \f(CWm//gc\fR).  Modyfikowanie acucha docelowego rwnie resetuje
pozycj przeszukiwania.
.Sp
Moesz miesza porwnania \f(CWm//g\fR z \f(CWm/\eG.../g\fR, 
gdzie \f(CW\eG\fR jest zapewnieniem zerowej szerokoci, ktre trafia w
dokadnie t sam pozycj, gdzie skoczy ewentualny poprzedni
\f(CWm//g\fR.
Zapewnienie \f(CW\eG\fR nie jest obsugiwane bez modyfikatora \f(CW/g\fR;
obecnie bez \f(CW/g\fR, \f(CW\eG\fR, zachowuje si zupenie jak
\f(CW\eA\fR, lecz jest to przypadkowe i moe si w przyszoci zmieni.
.Sp
Przykady:
.Sp
.Vb 2
\&    # kontekst listowy
\&    ($one,$five,$fifteen) = (`uptime` =~ /(\ed+\e.\ed+)/g);
.Ve
.Vb 8
\&    # kontekst skalarny
\&    $/ = ""; $* = 1;  # $*, niezalecany w nowoczesnych perlach
\&    while (defined($paragraph = <>)) {
\&        while ($paragraph =~ /[a-z]['")]*[.!?]+['")]*\es/g) {
\&            $sentences++;
\&        }
\&    }
\&    print "$sentences\en";
.Ve
.Vb 10
\&    # uywanie m//gc z \eG
\&    $_ = "ppooqppqq";
\&    while ($i++ < 2) {
\&        print "1: '";
\&        print $1 while /(o)/gc; print "', pos=", pos, "\en";
\&        print "2: '";
\&        print $1 if /\eG(q)/gc;  print "', pos=", pos, "\en";
\&        print "3: '";
\&        print $1 while /(p)/gc; print "', pos=", pos, "\en";
\&    }
.Ve
Ostatni przykad powinien da:
.Sp
.Vb 6
\&    1: 'oo', pos=4
\&    2: 'q', pos=5
\&    3: 'pp', pos=7
\&    1: '', pos=7
\&    2: 'q', pos=8
\&    3: '', pos=8
.Ve
Przydatnym idiomem dla skanerw w rodzaju \f(CWlex\fR jest
\f(CW/\eG.../gc\fR. Moesz tak czy rne rodzaje wyrae regularnych,
majc tak moliwo przetwarzania acucha kawaek po kawaku, dokonujc
rnych akcji, zalenie od tego, ktre wyraenie zostao trafione. Kade
wyraenie prbuje trafi tam, gdzie poprzednie zakoczyo.
.Sp
.Vb 14
\& $_ = <<'EOL';
\&      $url = new URI::URL "http://www/";   die if $url eq "xXx";
\& EOL
\& LOOP:
\&    {
\&      print(" digits"),         redo LOOP if /\eG\ed+\eb[,.;]?\es*/gc;
\&      print(" lowercase"),      redo LOOP if /\eG[a-z]+\eb[,.;]?\es*/gc;
\&      print(" UPPERCASE"),      redo LOOP if /\eG[A-Z]+\eb[,.;]?\es*/gc;
\&      print(" Capitalized"),    redo LOOP if /\eG[A-Z][a-z]+\eb[,.;]?\es*/gc;
\&      print(" MiXeD"),          redo LOOP if /\eG[A-Za-z]+\eb[,.;]?\es*/gc;
\&      print(" alphanumeric"),   redo LOOP if /\eG[A-Za-z0-9]+\eb[,.;]?\es*/gc;
\&      print(" line-noise"),     redo LOOP if /\eG[^A-Za-z0-9]+/gc;
\&      print ". That's all!\en";
\&    }
.Ve
Oto wyjcie (podzielone na kilka linii):
.Sp
.Vb 4
\& 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!
.Ve
.Ip "q/\s-1ACUCH\s0/" 8
.IX Item "q/\s-1ACUCH\s0/"
.Ip "\f(CW'ACUCH'\fR" 8
.IX Item "\f(CW'ACUCH'\fR"
Pojedynczo zacytowany acuch 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.
.Sp
.Vb 3
\&    $foo = q!I said, "You said, 'She said it.'"!;
\&    $bar = q('This is it.');
\&    $baz = '\en';                # acuch dwuznakowy
.Ve
.Ip "qq/\s-1ACUCH\s0/" 8
.IX Item "qq/\s-1ACUCH\s0/"
.Ip "\*(N"\s-1ACUCH\s0\*(T"" 8
.IX Item "\*(N"\s-1ACUCH\s0\*(T""
acuch w podwjnych cudzysowach, interpolowany.
.Sp
.Vb 4
\&    $_ .= qq
\&     (*** The previous line contains the naughty word "$1".\en)
\&                if /(tcl|rexx|python)/;      # :-)
\&    $baz = "\en";                # acuch jednoznakowy
.Ve
.Ip "qx/\s-1ACUCH\s0/" 8
.IX Item "qx/\s-1ACUCH\s0/"
.Ip "`\s-1ACUCH\s0`" 8
.IX Item "`\s-1ACUCH\s0`"
acuch, ktry jest interpolowany, a nastpnie uruchamainay jako komenda
systemowa. Zebrane standardowe wyjcie komendy jest zwracane. W kontekcie
skalarnym, pojawia si jako pojedynczy, wieloliniowy acuch.
W kontekcie listowym, jest rozdzielony na list linii (jakkolwiek
zdefiniowae linie $/ lub \f(CW$INPUT_RECORD_SEPARATOR\fR).
.Sp
.Vb 1
\&    $today = qx{ date };
.Ve
Zobacz sekcj o operatorach I/O.
.Ip "qw/\s-1ACUCH\s0/" 8
.IX Item "qw/\s-1ACUCH\s0/"
Zwraca list sw, wycignitych z acucha przy uyciu osadzonych biaych
spacji, jako ogranicznikw sw. Jest to rwnowane
.Sp
.Vb 1
\&    split(' ', q/ACUCH/);
.Ve
Pewne czsto uywane przykady:
.Sp
.Vb 2
\&    use POSIX qw( setlocale localeconv )
\&    @EXPORT = qw( foo bar baz );
.Ve
Czstym bdem jest prba rozdzielania sw przecinkiem, lub wstwianie do
wieloliniowych acuchw qw komentarzy. W tej sytuacji, przecznik
\f(CW-w\fR daje ostrzeenia jeli acuch zawiera znaki \*(L"#\*(R".
.Ip "s/\s-1WZORZEC/ZAMIANA/\s0egimosx" 8
.IX Item "s/\s-1PATTERN/REPLACEMENT/\s0egimosx"
Szuka w acuchu wzorca, a jeli go znajdzie, to zamienia go tekstem zamiany
i zwraca liczb zamian. W przeciwnym wypadku zwraca fasz (specyficznie
pusty acuch).
.Sp
Jeli przez operator \f(CW=~\fR lub \f(CW!~\fR nie podano acucha, uywana
jest zmienna \f(CW$_\fR. (acuch podany przez \f(CW=~\fR musi
by zmienn skalarn, elementem tablicy, tablicy asocjacyjnej, lub 
przypisaniem do jednego z nich, czyli lwartoci.)
.Sp
Jeli wybrany ogranicznik jest pojedynczym cudzysowem, nie dokonywana jest
interpolacja ani zmiennych \s-1WZORCA\s0, ani \s-1ZAMIANY\s0. W przeciwnym
wypadku, jeli
\s-1WZORZEC\s0 zawiera $, ktry wyglda bardziej jak zmienna, ni test koca
acucha, zmienna bdzie interpolowana w czasie dziaania.
Jeli chcesz, by wzorzec by kompilowany tylko raz, za pierwsz interpolacj
zmiennej, uyj opcji \f(CW/o\fR. Jeli wzorzec jest analizowany jako acuch
null, uzywane jest zamiast tego ostatnie normalne wyraenie regularne.
Zobacz jeszcze podrcznik \fIperlre\fR(1).
Zobacz te \fIperllocale\fR(1), aby dowiedzie si o wpywie \f(CWuse
locale\fR.
.Sp
Opcje to:
.Sp
.Vb 7
\&    e   Analizuj praw stron jako wyraenie
\&    g   Zamieniaj globalnie
\&    i   Nie zwracaj uwagi na wielko liter
\&    m   Traktuj acuch jak wiele linii
\&    o   Kompiluj wzorzec tylko raz
\&    s   Traktuj acuch jako pojedyncz lini
\&    x   Uyj rozszerzonych wyrae regularnych
.Ve
Ukoniki mog by zamienione przez dowolny, niealfanumeryczny i
niebiaospacjowy ogranicznik. Jeli uyte s pojedyncze cudzysowy, nie
dokonywana jest interpretacja acucha zamiany (modyfikator \f(CW/e\fR
przecia to zachowanie). W przeciwniestwie do perla 4, perl 5 traktuje
odwrotne cudzysowy jako normalne ograniczniki; tekst zamiany nie jest 
wykonywany jako komenda.
Jeli \s-1WZORZEC\s0 jest rozdzielany cytatami nawiasowymi, \s-1ZAMIANA\s0
ma swoj wasn par cytatw, ktra moe, lub nie, by cytatami nawiasowymi, np.
\f(CWs(foo)(bar)\fR lub \f(CWs<foo>/bar/\fR.  \f(CW/e\fR spowoduje, e
porcja zamiany zostanie zinterpretowana jako pene perlowe wyraenie i
z\fIeval()\fRowana zaraz potem. Jego skadnia jest jednak sprawdzania
podczas kompilacji.
.Sp
Przykady:
.Sp
.Vb 1
\&    s/\ebgreen\eb/mauve/g;                # nie zmieniaj wintergreen
.Ve
.Vb 1
\&    $path =~ s|/usr/bin|/usr/local/bin|;
.Ve
.Vb 1
\&    s/Login: $foo/Login: $bar/; # wzorzec czasu dziaania
.Ve
.Vb 1
\&    ($foo = $bar) =~ s/this/that/;
.Ve
.Vb 1
\&    $count = ($paragraph =~ s/Mister\eb/Mr./g);
.Ve
.Vb 4
\&    $_ = 'abc123xyz';
\&    s/\ed+/$&*2/e;               # daje 'abc246xyz'
\&    s/\ed+/sprintf("%5d",$&)/e;  # daje 'abc  246xyz'
\&    s/\ew/$& x 2/eg;             # daje 'aabbcc  224466xxyyzz'
.Ve
.Vb 3
\&    s/%(.)/$percent{$1}/g;      # zmie eskejpy procentowe; bez /e
\&    s/%(.)/$percent{$1} || $&/ge;       # teraz z wyraenim, z /e
\&    s/^=(\ew+)/&pod($1)/ge;      # uyj wywoania funkcji
.Ve
.Vb 3
\&    # /e mog si zagnieda; to rozwinie
\&    # proste zmienne osadzone w $_
\&    s/(\e$\ew+)/$1/eeg;
.Ve
.Vb 6
\&    # Usu komentarze C
\&    $program =~ s {
\&        /\e*     # Traf na rozdzielacz otwierajcy.
\&        .*?     # Traf w minimaln liczb znakw.
\&        \e*/     # Traf w rozdzielacz zamykajcy.
\&    } []gsx;
.Ve
.Vb 1
\&    s/^\es*(.*?)\es*$/$1/;        # odetnij bia spacj
.Ve
.Vb 1
\&    s/([^ ]*) *([^ ]*)/$2 $1/;  # zamie 1-sze 2 pola
.Ve
Zauwa, e w ostatnim przykadzie zamiast $ uyto \e. W przeciwiestwie do
\fBsed\fR(1)a, uywamy postaci \e<\fIcyfra\fR> tylko po lewej stronie.
Wszdzie indziej, jest to $<\fIcyfra\fR>.
.Sp
Czasami nie mona uy po prostu \f(CW/g\fR, aby zaszy wszystkie zmiany.
Oto dwa popularne przypadki:
.Sp
.Vb 3
\&    # wstaw przecinki we waciwych miejscach integera
\&    1 while s/(.*\ed)(\ed\ed\ed)/$1,$2/g;      # perl4
\&    1 while s/(\ed)(\ed\ed\ed)(?!\ed)/$1,$2/g;  # perl5
.Ve
.Vb 2
\&    # rozwi tabulacje na 8-kolumnowe spacje
\&    1 while s/\et+/' ' x (length($&)*8 - length($`)%8)/e;
.Ve
.Ip "tr/\s-1LISTASZUKANIA/LISTAZAMIANY/\s0cds" 8
.IX Item "tr/\s-1SEARCHLIST/REPLACEMENTLIST/\s0cds"
.Ip "y/\s-1LISTASZUKANIA/LISTAZAMIANY/\s0cds"
.IX Item "y/\s-1SEARCHLIST/REPLACEMENTLIST/\s0cds" 8
Tumaczy wszystkie pojawienia si znakw, znalezione w licie szukania, na
odpowiadajce znaki z listy zamiany. Zwraca liczb zamienionych, lub
skasowanych znakw. Jeli nie podano acucha w operatorze =~ lub !~, uywane
jest \f(CW$_\fR. (acuch okrelony przez =~ musi by zmienn skalarn,
elementem tablicy, elementem tablicy asocjacyjnej, lub przypisaniem do
jednego z nich, czyli lwartoci).
Dla mionikw edytora \fBsed\fR(1), udostpniono synonim \f(CWtr\fR pod
nazw \f(CWy\fR. Jeli \s-1LISTASZUKANIA\s0 jest rozdzielona
nawiasami, to \s-1LISTAZAMIANY\s0 nie musi ich mie, np.
\f(CWtr[A-Z][a-z]\fR lub \f(CWtr(+-*/)/ABCD/\fR.
.Sp
Opcje:
.Sp
.Vb 3
\&    c   Dopenij LISTSZUKANIA
\&    d   Kasuj znalezione, lecz niezamienione znaki
\&    s   Zmiad zduplikowane zamienione znaki
.Ve
Jeli podany jest modyfikator \f(CW/c\fR, zbir znakw z
\s-1LISTYSZUKANIA\s0 jest dopeniany. Jeli podany jest modyfikator
\f(CW/d\fR, wszelkie znaki, podane w \s-1LICIESZUKANIA\s0, a nie znalezione
w \s-1LICIEZAMIANY\s0 s kasowane.
Jeli podany jest modyfikator \f(CW/s\fR, to sekwencje, ktre zostay
przetumaczone do tego samego znaku s miadone do pojedynczej instancji
tego znaku.
.Sp
Jeli uyty jest modyfikator \f(CW/d\fR, \s-1LISTAZAMIANY\s0 jest zawsze
interpretowana tak, jak jest podana. W przeciwnym wypadku, gdy
\s-1LISTAZAMIANY\s0 jest krtsza ni \s-1LISTASZUKANIA\s0, ostatni jej znak 
jest replikowany tak dugo, a wypeni brakujce miejsca. Jeli
\s-1LISTAZAMIANY\s0 jest null, to replikowana jest \s-1LISTASZUKANIA\s0.
Jest to przydatne do zliczania znakw w klasie, lub dla miadenia sekwencji
znakowych klasy.
.Sp
Przykady:
.Sp
.Vb 1
\&    $ARGV[1] =~ tr/A-Z/a-z/;    # zmie na mae litery
.Ve
.Vb 1
\&    $cnt = tr/*/*/;             # zlicz gwiazdy w $_
.Ve
.Vb 1
\&    $cnt = $sky =~ tr/*/*/;     # zlicz gniazdy w $sky
.Ve
.Vb 1
\&    $cnt = tr/0-9//;            # zlicz cyfry w $_
.Ve
.Vb 1
\&    tr/a-zA-Z//s;               # bookkeeper -> bokeper
.Ve
.Vb 1
\&    ($HOST = $host) =~ tr/a-z/A-Z/;
.Ve
.Vb 1
\&    tr/a-zA-Z/ /cs;             # zmie niealfabetyczne na spacje
.Ve
.Vb 2
\&    tr [\e200-\e377]
\&       [\e000-\e177];             # skasuj 8-my bit
.Ve
Jeli dla znaku podano wiele translacji, uywana jest tylko pierwsza:
.Sp
.Vb 1
\&    tr/AAA/XYZ/
.Ve
przetumaczy A na X.
.Sp
Zauwa, e z uwagi na to, e tablica translacji jest budowana w czasie
kompilacji, ani \s-1LISTASZUKANIA\s0, ani \s-1LISTAZAMIANY\s0 nie podlegaj
interpolacji cudzysowowej. Znaczy to, e jeli chcesz uywa zmiennych,
musisz uy \fIeval()\fR:
.Sp
.Vb 2
\&    eval "tr/$oldlist/$newlist/";
\&    die $@ if $@;
.Ve
.Vb 1
\&    eval "tr/$oldlist/$newlist/, 1" or die $@;
.Ve
.Sh "Operatory I/O"
.IX Subsection "I/O Operators"
Istnieje wiele operatorw I/O (wejcia/wyjcia), o ktrych powiniene
wiedzie.
acuch ujty w odwrotne cudzysowy podlega najpierw podstawieniu zmiennych,
podobnie jak acuch ujty w podwjne cudzysowy. Nastpnie jest
interpretowany jako komenda, a jej wyjcie jest wartoci pseudoliterau,
jak w powoce. W kontekcie skalarnym, zwracany jest pojedynczy acuch,
skdajcy si z caego wyjcia. W kontekcie listowym, zwracana jest lista
wartoci dla kadej linii wyjcia. (Mona ustawi \f(CW$/\fR, co przeciy
domylny terminator linii.)
Komenda jest wykonywana przy kadej analizie pseudoliterau. Status komendy
jest zwracany do \f(CW$?\fR (zobacz podrcznik \fIperlvar\fR(1)).
W przeciwiestwie do \fBcsh\fR(1), nie jest na danych
zwracanych dokonywana translacja \*-- nowe linie pozostaj nowymi liniami. W
przeciwiestwie do wszelkich innych powok, pojedyncze cudzysowyu nie
ukrywaj nazw zmiennych w komendzie od interpretacji. Aby przekaza $ dalej,
naley go wycytowa odwrotnym ukonikiem.
Ogln postaci odwrotnych cudzysoww jest \f(CWqx//\fR. (Poniewa podlegaj
one zawsze rwnie rozwiniciu przez powok, zobacz podrcznik
\fIperlsec\fR(1), ktry opisuje problemy bezpieczestwa.)
.PP
Analiza uchwytu pliku, ktry jest w nawiasach trjktnych, wyciga z pliku
nastpn lini, lub \f(CWundef\fR na jego kocu.
Normalnie, musisz zmiennej przypisa warto, lecz jest sytuacja, w ktrej
nastpuje automatyczne przypisanie. \fIJeli i \s-1TYLKO\s0 jeli\fR symbol
wejcia jest jedyn rzecz wewntrz warunku ptli \f(CWwhile\fR lub
\f(CWfor(;;)\fR, to warto jest przypisywana automatycznie zmiennej
\f(CW$_\fR. 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 rwnowane:
.PP
.Vb 5
\&    while (defined($_ = <STDIN>)) { print; }
\&    while (<STDIN>) { print; }
\&    for (;<STDIN>;) { print; }
\&    print while defined($_ = <STDIN>);
\&    print while <STDIN>;
.Ve
Uchwyty plikw \s-1STDIN\s0, \s-1STDOUT\s0 i \s-1STDERR\s0 to uchwyty
predefiniowane. Uchwyty \f(CWstdin\fR, \f(CWstdout\fR i
\f(CWstderr\fR te bd dziaa, lecz nie w pakietach, w ktrych s
interpretowane jako lokalne identyfikatory nie za jako globalne.)
Dodatkowe uchwyty plikw mona tworzy funkcj \fIopen()\fR. Zobacz jej opis
w podrczniku \fIperlfunc\fR(1).
.PP
Jeli <\s-1UCHWYTPLIKU\s0 jest uywany w kontekcie, oczekujcym listy,
zwracana jest lista, skadajca si ze wszystkich linii wejciowych, jedna
linia na element listy. atwo jest zaj tak duy obszar danych, wic uywaj
tego ostronie.
.PP
Zerowy uchwyt pliku <> jest specjalny i moe by uywany do emulacji
zachowania edytora \fBsed\fR(1), lub \fBawk\fR(1). Wejcie z <> moe
nadchodzi zarwno ze standardowego wejcia, lub z kadego pliku,
wymienionego w linii komend. Oto jak to dziaa: za pierwsz analiz <>,
sprawdzana jest tablica \f(CW@ARGV\fR i jeli jest zerowa,
\f(CW$ARGV[0]\fR jest ustawiane na \*(L"\-\*(R", co oznacza po otwarciu 
standardowe wejcie. Tablica \f(CW@ARGV\fR jest nastpnie przetwarzana jako
lista nazw plikw.
Ptla
.PP
.Vb 3
\&    while (<>) {
\&        ...                     # kod dla kadej linii
\&    }
.Ve
jest rwnowana nastpujcemu pseudokodowi:
.PP
.Vb 7
\&    unshift(@ARGV, '-') unless @ARGV;
\&    while ($ARGV = shift) {
\&        open(ARGV, $ARGV);
\&        while (<ARGV>) {
\&            ...         # kod dla kadej linii
\&        }
\&    }
.Ve
poza tym, e jest troch adniejsza i dziaa. Naprawd przesuwa tablic
\f(CW@ARGV\fR i wstawia biec nazw pliku do zmiennej \f(CW$ARGV\fR.
Uywa te wewntrznie uchwytu \fI\s-1ARGV\s0\fR--<> jest po prostu synonimem
<\s-1ARGV\s0>, ktry jest magiczny. (Powyszy pseudokod nie dziaa, gdy
traktuje \s-1ARGV\s0 amagicznie.)
.PP
Przed pierwszym <> moesz modyfikowa \f(CW@ARGV\fR, o ile tablica bdzie
zawieraa list plikw, ktrych oczekujesz. Numey linii (\f(CW$.\fR) s
liczone tak, jakby wejcie byo tylko jednym, szczliwym plikiem. (Lecz
zobacz przykad z \fIeof()\fR, aby zobaczy jak zresetowa numery linii.)
.PP
Jeli chcesz ustawi \f(CW@ARGC\fR na swoj wasn list plikw, to nie ma
sprawy. Jeli chcesz przekaza do swojego skryptu przeczniki, moesz uy
jednego z moduw Getopts, lub wstawi na pocztku podobn ptl:
.PP
.Vb 10
\&    while ($_ = $ARGV[0], /^-/) {
\&        shift;
\&        last if /^--$/;
\&        if (/^-D(.*)/) { $debug = $1 }
\&        if (/^-v/)     { $verbose++  }
\&        ...             # inne przeczniki
\&    }
\&    while (<>) {
\&        ...             # kod dla kadej linii
\&    }
.Ve
Symbol <> zwraca \s-1FALSE\s0 tylko raz. Jesli wywoasz go po tym, zaoy,
e przetwarzasz now list \f(CW@ARGV\fR i jeli jej nie ustawie, pobierze
wejcie ze \s-1STDIN\s0.
.PP
Jeli acuch wewntrz nawiasw trjktnych jest wskazaniem do zmiennej 
skalarnej (np. <$foo>), to zmienna ta przechowuje nazw uchwytu, z ktrego
pobierane jest wejcie. Np:
.PP
.Vb 2
\&    $fh = \e*STDIN;
\&    $line = <$fh>;
.Ve
acuch w nawiasach trjktnych 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 \f(CW<$foo>\fR, 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: \f(CW<${foo}>\fR. Dzi jednak, za czystsze uwaa si
bezporednie woanie funkcji wewntrznej -- \f(CWglob($foo)\fR. Przykad:
.PP
.Vb 3
\&    while (<*.c>) {
\&        chmod 0644, $_;
\&    }
.Ve
jest rwnowany
.PP
.Vb 5
\&    open(FOO, "echo *.c | tr -s ' \et\er\ef' '\e\e012\e\e012\e\e012\e\e012'|");
\&    while (<FOO>) {
\&        chop;
\&        chmod 0644, $_;
\&    }
.Ve
W rzeczywistoci, obecnie jest to wanie tak zaimplementowane. (Co znaczy,
e nie bdzie dziaa na nazwach plikw ze spacjami, chyba e masz u siebie
\fIcsh\fR(1).) Oczywicie najkrtszym sposobem dokonania powyszego jest:
.PP
.Vb 1
\&    chmod 0644, <*.c>;
.Ve
Poniewa globowanie uywa powoki, czsto szybciej jest wywoa samodzielnie
\fIreaddir()\fR i dokona \fIgrep()\fRa na nazwach plikw. Co wicej, z
powodu obecnej implementacji, wywoanie \fIglob()\fR moe
napotka bdy w rodzaju \*(L"Arg list too
long\*(R" (chyba e zainstalowae \fItcsh\fR\|(1L) jako \fI/bin/csh\fR).
.PP
Glob analizuje swj (osadzony) argument tylko jeli rozpoczyna now list.
Wszystkie wartoci musz by odczytane zanim znw rozpocznie. W kontekcie
listowym nie jest to istotne, gdy autmatycznie odczytujesz wszystkie.
Jednak w kontekcie skalarnym, operator zwraca nastpn warto za kadym
wywoaniem, lub \s-1FALSE\s0 na kocu. Znowu, \s-1FALSE\s0 jest zwracane
tylko raz. Jeli wic oczekujesz od globa pojedynczej wartoci, to lepiej
powiedzie
.PP
.Vb 1
\&    ($file) = <blurch*>;
.Ve
a nie
.PP
.Vb 1
\&    $file = <blurch*>;
.Ve
gdy to drugie bdzie rozrnia zwrcenie nazwy plikw i zwrcenie
\s-1FALSE\s0.
.PP
Jeli prbujesz dokona interpolacji zmiennych, to zdecydowanie lepiej jest
uy funkcji \fIglob()\fR, gdy starsza notacja moe spowodowa zakopotanie
u niektrych osb.
.PP
.Vb 2
\&    @files = glob("$dir/*.[ch]");
\&    @files = glob($files[$i]);
.Ve
.Sh "Zawijanie staych"
.IX Subsection "Constant Folding"
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 efektw ubocznych. W szczeglnoci, np.
konkatenacja literaw bez podstawie zmiennych jest dokonywana podczas 
kompilacji. Interpretacja odwrotnych ukonikw nastpuje rwnie podczas 
kompilacji. Moesz powiedzie
.PP
.Vb 2
\&    'Now is the time for all' . "\en" .
\&        'good men to come to.'
.Ve
a wszystko to wewntrznie zredukuje si do jednego acucha. Podobnie, jeli
powiesz
.PP
.Vb 3
\&    foreach $file (@filenames) {
\&        if (-s $file > 5 + 100 * 2**16) { ... }
\&    }
.Ve
to kompilator przeliczy liczby, ktre reprezentuje wyraenie.
.Sh "Arytmetyka cakowita"
.IX Subsection "Integer Arithmetic"
Domylnie, perl wykonuje wszystkie obliczenia zmiennoprzecinkowo. Jednak
powiedzenie
.PP
.Vb 1
\&    use integer;
.Ve
mwi kompilatorowi, e moe uywa odtd, do koca bloku operacji
cakowitych. Wewntrzne bloki mog temu zaprzeczy, mwic
.PP
.Vb 1
\&    no integer;
.Ve
co wystarcza do koca ich bloku.
.PP
Operatory bitowe ("&\*(R", \*(L"|\*(R", \*(L"^\*(R", \*(L"~\*(R", \*(L"<<\*(R",
i \*(L">>") zawsze daj wyniki cakowite. Jednak \f(CWuse integer\fR ma
wci dla nich znaczenie. Domylnie ich wyniki s interpretowane jako liczby
cakowite bez znaku. Po wczeniu tej opcji, sa interpretowane ze znakiem.
Np. \f(CW~0\fR normalnie jest analizowane do wielkiej wartoci cakowitej.
Po \f(CWuse integer; ~0\fR staje si \-1.
.Sh "Arytmetyka zmiennoprzecinkowa"
.IX Subsection "Floating-point Arithmetic"
Podczas gdy \f(CWuse integer\fR daje arytmetyk cakowit, nie ma podobnej
instrukcji dla dawania zaokrgle, lub odci w konkretnych miejscach
dziesitnych. Dla zaokrgle do okrelonej iloci cyfr, najlepiej uy
\fIsprintf()\fR lub \fIprintf()\fR.
.PP
Modu \s-1POSIX\s0 (cz standardowej dystrybucji perla) 
implementuje funkcje \fIceil()\fR, \fIfloor()\fR i kilka
innych funkcji matematycznych i trygonometrycznych. Modu Math::Complex
(rwnie standardowy) definiuje sporo funkcji matematycznych, ktre mog
dziaa rwnie na liczbach rzeczywistych. Modu Math::Complex nie jest tak
wydajny jak \s-1POSIX\s0, lecz \s-1POSIX\s0 nie moe dziaa na liczbach
zespolonych.
.PP
Zaokrglanie w aplikacjach finansowych moe mie powane konsekwencje i
uywana metoda powinna by podawana dokadnie. W tych wypadkach, lepiej nie
ufa temu, ktry system zaokrglania jest uywany przez perla, lecz
zaimplementowa tak funkcj samodzielnie.

.rn }` ''