Linux Certif

Toute la documentation sur la certification Linux LPI

perlfunc

NAZWA

perlfunc - Wbudowane funkcje perla

OPIS

Funkcje z tej sekcji mog± s³u¿yæ pomoc± w wyra¿eniach. Podpadaj± one pod dwie g³ówne kategorie: operatory list, oraz nazwane operatory jednoargumentowe. [Przyp. t³um.: w perlu nie ma prawdziwych funkcji, s± operatory] Ró¿ni± siê one w zwi±zku priorytetowym przecinkiem. (zobacz tablicê priorytetów na stronie perlop(1).). Operatory list pobieraj± wiêcej ni¿ jeden argument, podczas gdy operatory jednoargumentowe, z definicji, nigdy nie bior± wiêcej ni¿ jeden argument. Tak wiêc przecinek koñczy argument operatora jednoargumentowego, lecz jedynie rozdziela argumenty operatora listy. Ogólnie, operator jednoargumentowy daje swojemu argumentowi kontekst skalarny, podczas gdy operator listowy mo¿e dawaæ zarówno kontekst skalarny, jak i listowy. Je¶li daje obydwa, to argumenty skalarne bêd± najpierw, a za nimi nast±pi± argumenty listowe. (Zauwa¿, ¿e mo¿e istnieæ tylko jeden argument listowy.) Np. funkcja splice() ma trzy argumenty skalarne, za którymi nastêpuje lista.

W opisach sk³adni, które s± ni¿ej, operatory list, które oczekuj± listy (i daj± kontekst listowy elementom tej listy) s± pokazywane z argumentem LISTA. Lista taka mo¿e sk³adaæ siê z dowolnej kombinacji argumentów skalarnych lub warto¶ci listowych; warto¶ci listowe bêd± w³±czone w listê tak, jakby ka¿dy pojedynczy element by³ interpolowany w tym punkcie listy, tworz±c d³u¿sz±, jednowymiarow± warto¶æ listow±. Elementy typu LISTA powinny byæ oddzielone przecinkami.

Ka¿da funkcja z poni¿szej listy, mo¿e byæ u¿yta bez, albo z nawiasami wokó³ swoich argumentów. (Opisy sk³adni pomijaj± nawiasy.) Je¶li u¿ywasz nawiasów, to prosta (lecz czasem zaskakuj±ca) regu³a jest taka: WYGL¡DA jak funkcja, wiêc JEST funkcj± i priorytet nie ma znaczenia. W przeciwnym wypadku jest to operator listowy lub operator jednoargumentowy i priorytet siê liczy. I bia³a spacja miêdzy funkcj± i lewym nawiasem nie liczy siê---wiêc musisz byæ czasem ostro¿ny:

    print 1+2+4;        # Drukuje 7.

    print(1+2) + 4;     # Drukuje 3.

    print (1+2)+4;      # Te¿ drukuje 3!

    print +(1+2)+4;     # Drukuje 7.

    print ((1+2)+4);    # Drukuje 7.

Je¶li uruchamiasz perla z prze³±cznikiem -w, to bêdziesz o tym ostrzegany. Na przyk³ad trzecia z powy¿szych linii daje w efekcie:

    print (...) interpreted as function at - line 1.

    Useless use of integer addition in void context at - line 1.

Dla instrukcji, które mog± byæ u¿ywane zarówno w kontekstach skalarnych, jak i listowych, b³±d nie wymagaj±cy przerwania jest ogólnie wskazywany w kontek¶cie skalarnym przez zwrot niezdefiniowanej warto¶ci, a w kontek¶cie listowym przez zwrot listy null.

Zapamiêtaj nastêpuj±c± regu³ê:

NIE ISTNIEJE OGÓLNA REGU£A KONWERSJI LISTY W SKALAR!

Ka¿dy operator i funkcja decyduje, jaki rodzaj warto¶ci jest najbardziej odpowiedni do zwrócenia w kontek¶cie skalarnym. Niektóre operatory zwracaj± d³ugo¶æ listy, która by³aby zwrócona w kontek¶cie listowym. Niektóre zwracaj± pierwsz± warto¶æ listy. Niektóre zwracaj± ostatni± warto¶æ listy. Inne zwracaj± liczbê pomy¶lnych operacji. Ogólnie, robi± one to, czego chcesz, chyba ¿e oczekujesz spójno¶ci.

Funkcje perla wed³ug kategorii

Oto funkcje perla (w³±czaj±c rzeczy, które wygl±daj± jak funkcje, np. niektóre s³owa kluczowe i nazwane operatory), pouk³adane wed³ug kategorii. Niektóre funkcje pojawiaj± siê w wiêcej ni¿ jednym miejscu.

Funkcje dla skalarów lub ³añcuchów

chomp, chop, chr, crypt, hex, index, lc, lcfirst, length, oct, ord, pack, q/£AÑCUCH/, qq/£AÑCUCH/, reverse, rindex, sprintf, substr, tr///, uc, ucfirst, y///

Wyra¿enia regularne i porównywanie wzorców

m//, pos, quotemeta, s///, split, study

Funkcje numeryczne

abs, atan2, cos, exp, hex, int, log, oct, rand, sin, sqrt, srand

Funkcje dla prawdziwych tablic (@ARRAYs)

pop, push, shift, splice, unshift

Funkcje dla danych listowych

grep, join, map, qw/£AÑCUCH/, reverse, sort, unpack

Funkcje dla %HASHów (tablic asocjacyjnych)

delete, each, exists, keys, values

Funkcje wej¶cia i wyj¶cia

binmode, close, closedir, dbmclose, dbmopen, die, eof, fileno, flock, format, getc, print, printf, read, readdir, rewinddir, seek, seekdir, select, syscall, sysread, sysseek, syswrite, tell, telldir, truncate, warn, write

Funkcje dla danych o okre¶lonej d³ugo¶ci lub rekordów

pack, read, syscall, sysread, syswrite, unpack, vec

Funkcje dla deskryptorów plików, plików lub katalogów

-X, chdir, chmod, chown, chroot, fcntl, glob, ioctl, link, lstat, mkdir, open, opendir, readlink, rename, rmdir, stat, symlink, umask, unlink, utime

S³owa kluczowe zwi±zane z kontrol± dzia³ania programu

caller, continue, die, do, dump, eval, exit, goto, last, next, redo, return, sub, wantarray

S³owa kluczowe zwi±zane z zakresami

caller, import, local, my, package, use

Ró¿ne funkcje

defined, dump, eval, formline, local, my, reset, scalar, undef, wantarray

Funkcje dla procesów i grup procesów

alarm, exec, fork, getpgrp, getppid, getpriority, kill, pipe, qx/£AÑCUCH/, setpgrp, setpriority, sleep, system, times, wait, waitpid

S³owa kluczowe zwi±zane z modu³ami perla

do, import, no, package, require, use

S³owa kluczowe zwi±zane z klasami i obiektowo¶ci±

bless, dbmclose, dbmopen, package, ref, tie, tied, untie, use

Niskopoziomowe funkcje gniazd

accept, bind, connect, getpeername, getsockname, getsockopt, listen, recv, send, setsockopt, shutdown, socket, socketpair

Funkcje komunikacji miêdzyprocesowej Systemu V

msgctl, msgget, msgrcv, msgsnd, semctl, semget, semop, shmctl, shmget, shmread, shmwrite

Pobieranie informacji u¿ytkownika i grupy

endgrent, endhostent, endnetent, endpwent, getgrent, getgrgid, getgrnam, getlogin, getpwent, getpwnam, getpwuid, setgrent, setpwent

Pobieranie informacji sieciowej

endprotoent, endservent, gethostbyaddr, gethostbyname, gethostent, getnetbyaddr, getnetbyname, getnetent, getprotobyname, getprotobynumber, getprotoent, getservbyname, getservbyport, getservent, sethostent, setnetent, setprotoent, setservent

Funkcje zwi±zane z czasem

gmtime, localtime, time, times

Funkcje nowe w perl5

abs, bless, chomp, chr, exists, formline, glob, import, lc, lcfirst, map, my, no, prototype, qx, qw, readline, readpipe, ref, sub*, sysopen, tie, tied, uc, ucfirst, untie, use

* - sub by³o s³owem kluczowym w perl4, lecz w perl5 jest to operator, który mo¿e byæ u¿ywany w wyra¿eniach.

Funkcje przedawnione w perl5

dbmclose, dbmopen

Alfabetyczny listing funkcji perla

-X UCHWYTPLIKU

-X WYRA¯

-X

Test pliku, gdzie X jest jedn± z ni¿ej wymienionych liter. Ten jednoargumentowy operator pobiera argument, nazwê pliku lub jego uchwyt. Nastêpnie testuje plik i sprawdza, czy co¶ jest w nim prawdziwe. Je¶li argument zostanie pominiêty, testuje $_, nie licz±c -t, które testuje STDIN. Zasadniczo zwraca 1 dla wyniku pozytywnego i '' dla negatywnego, a warto¶æ niezdefiniowan±, je¶li plik nie istnieje. Mimo ¶miesznych nazw, priorytety s± takie same jak ka¿dym innym nazwanym operatorze jednoargumentowym i argument mo¿e byæ otoczony nawiasami. Operator mo¿e byæ jednym z:

    -r  Plik jest odczytywalny przez efektywny uid/gid.

    -w  Plik jest zapisywalny przez efektywny uid/gid.

    -x  Plik jest wykonywalny przez efektywny uid/gid.

    -o  W³a¶cicielem pliku jest efektywny uid.

    -R  Plik jest odczytywalny przez rzeczywisty uid/gid.

    -W  Plik jest zapisywalny przez rzeczywisty uid/gid.

    -X  Plik jest wykonywalny przez rzeczywisty uid/gid.

    -O  W³a¶cicielem pliku jest rzeczywisty uid.

    -e  Plik istnieje.

    -z  Plik ma rozmiar zerowy.

    -s  Plik ma rozmiar niezerowy (zwraca rozmiar).

    -f  Plik jest prostym plikiem.

    -d  Plik jest katalogiem.

    -l  Plik jest dowi±zaniem symbolicznym.

    -p  Plik jest nazwanym potokiem (FIFO).

    -S  Plik jest gniazdem.

    -b  Plik jest blokowym plikiem specjalnym.

    -c  Plik jest znakowym plikiem specjalnym.

    -t  Uchwyt pliku jest otwarty do tty.

    -u  Plik ma ustawiony bit `setuid'.

    -g  Plik ma ustawiony bit `setgid'.

    -k  Plik ma ustawiony bit `sticky'.

    -T  Plik jest plikiem tekstowym.

    -B  Plik jest plikiem binarnym (przeciwieñstwo -T).

    -M  Wiek pliku w dniach, gdy uruchomi³ siê skrypt

    -A  To samo dla czasu dostêpu.

    -C  To samo dla zmiany informacji inode.

Interpretacja operatorów praw pliku -r, -R, -w, -W, -x i -X bazuje jedynie na prawach pliku i uid/gid u¿ytkownika. Mog± istnieæ inne powody, dla których w rzeczywisto¶ci nie mo¿esz go odczytaæ, zapisaæ lub uruchomiæ. Zauwa¿ te¿, ¿e dla superu¿ytkownika, operatory -r, -R, -w, i -W zawsze zwracaj± 1, a -x i -X zwracaj± 1, je¶li ustawiony jest tak dowolny bit wykonania. Skrypty uruchamiane przez superu¿ytkownika powinny wiêc wywo³ywaæ do celów testowania praw pliku funkcjê stat() lub tymczasowo zmieniæ uid na co¶ innego.

Przyk³ad:

    while (<>) {

        chop;

        next unless -f $_;      # ignoruj specjalne

        ...

    }

Zauwa¿, ¿e -s/a/b/ nie dokonuje zanegowanego podstawienia. Powiedzenie -exp($foo) dzia³a wci±¿ zgodnie z oczekiwaniami, jednak jedynie pojedyncze litery za znakiem minusa s± interpretowane jako testy plikowe.

Prze³±czniki -T i -B dzia³aj± tak, ¿e testuj± pierwszy blok pliku w poszukiwaniu dziwnych znaków, takich jak dziwne kody steruj±ce, lub znaki z wysokiego zestawu znaków. Je¶li jest ich zbyt wiele (>30%), to jest to plik -B, w przeciwnym wypadku to plik -T. Dodatkowo, ka¿dy plik, zawieraj±cy w pierwszym bloku null jest uwa¿any za plik binarny. Je¶li -T lub -B jest u¿ywane na uchwycie pliku, to testowany jest bie¿±cy bufor standardowego wej¶cia zamiast pierwszego bloku. Zarówno -T jak i -B zwracaj± odpowied¼ pozytywn± dla pliku null lub pliku, który jest na EOF podczas testowania jego uchwytu. Z uwagi na to, ¿e dla testu -T trzeba odczytaæ plik, w wiêkszo¶ci przypadków u¿ywa siê najpierw -f, jak w next unless -f $file && -T $file.

Je¶li który¶ z operatorów testu plików (lub stat() czy lstat()) otrzyma³by specjalny uchwyt pliku, sk³adaj±cy siê z samego podkre¶lenia, to u¿yta zosta³aby struktura `stat' z poprzedniego testu pliku, oszczêdzaj±c wywo³ania systemowego. (Nie dzia³a to dla -t, a ponadto powiniene¶ pamiêtaæ, ¿e lstat() i -l zostawiaj± w strukturze warto¶ci dla dowi±zañ symbolicznych, a nie rzeczywistych plików.) Przyk³ad:

    print "Can do.\n" if -r $a || -w _ || -x _;

    stat($filename);

    print "Readable\n" if -r _;

    print "Writable\n" if -w _;

    print "Executable\n" if -x _;

    print "Setuid\n" if -u _;

    print "Setgid\n" if -g _;

    print "Sticky\n" if -k _;

    print "Text\n" if -T _;

    print "Binary\n" if -B _;

abs WARTO¦Æ

abs

Zwraca modu³ argumentu. Je¶li parametr WARTO¦Æ zostanie pominiêty, to u¿ywane jest $_.

accept NOWEGNIAZDO,GNIAZDO

Przyjmuje nadchodz±ce po³±czenie na gnie¼dzie, podobnie jak wywo³anie systemowe accept(2). Po sukcesie zwraca spakowany adres, a w razie pora¿ki FALSE. Przyk³ad u¿ycia mo¿na znale¼æ w sekcji Sockets: Client/Server Communication strony podrêcznika perlipc(1).

alarm SEKUNDY

alarm

Powoduje, ¿e sygna³ ALARM jest dostarczany do tego procesu po okre¶lonej liczbie sekund. Je¶li nie podano parametru sekund, u¿ywana jest warto¶æ zachowana w $_. (Niestety na niektórych maszynach czas mo¿e byæ do sekundy krótszy ni¿ ten, który podasz, zale¿nie od sposobu zliczania sekund.) Naraz odliczaæ mo¿e tylko jeden zegar. Ka¿de wywo³anie wy³±cza poprzedni zegar, a argument 0 wy³±cza poprzedni zegar bez uruchamiania nowego. Zwrócona warto¶æ jest ilo¶ci± czasu, pozostaj±cego poprzedniemu zegarowi.

Dla opó¼nieñ lub wiêkszej dok³adno¶ci ni¿ jedna sekunda, mo¿esz u¿yæ perlowego interfejsu syscall(), i dostaæ siê do setitimer(2), o ile twój system to obs³uguje. W przeciwnym wypadku obejrzyj opis select(), gdzie¶ w tym dokumencie. Ogólnie czêstym b³êdem jest ³±czenie wywo³añ alarm() i sleep().

Je¶li chcesz u¿ywaæ alarm() do timeout'owania wywo³ania systemowego, musisz u¿yæ pary eval/die. Nie mo¿na oczekiwaæ, ¿e alarm spowoduje, ¿e wywo³anie systemowe siê zakoñczy, z $! ustawionym na EINTR, gdy¿ na niektórych systemach perl ustawia obs³ugê sygna³ów tak, ¿e wywo³ania systemowe s± restartowane. U¿ywanie eval/die dzia³a zawsze.

    eval {

        local $SIG{ALRM} = sub { die "alarm\n" };       # NB \n wymagane

        alarm $timeout;

        $nread = sysread SOCKET, $buffer, $size;

        alarm 0;

    };

    die if $@ && $@ ne "alarm\n";       # propaguj b³êdy

    if ($@) {

        # timeout

    }

    else {

        # bez timeouta

    }

atan2 Y,X

Zwraca arcus tangens z Y/X, w zakresie -pi do pi.

Dla operacji tangens, mo¿esz u¿yæ funkcji POSIX::tan(), lub u¿yæ znanej relacji:

    sub tan { sin($_[0]) / cos($_[0])  }

bind GNIAZDO,NAZWA

Przywi±zuje adres sieciowy do gniazda, podobnie jak wywo³anie systemowe bind(2). Po sukcesie zwraca TRUE, a w przeciwnym wypadku FALSE. NAZWA powinna byæ spakowanym adresem, typu odpowiedniego dla gniazda. Zobacz przyk³ady w sekcji Sockets: Client/Server Communication na stronie podrêcznika perlipc(1).

binmode UCHWYTYPLIKU

Powoduje, ¿e plik prze³±cza siê w tryb binarny zapisu/odczytu. Ma to miejsce w systemach operacyjnych, które dokonuj± takiego rozró¿nienia. Pliki, które nie s± w trybie binarnym, ukrywaj± wej¶ciowe sekwencje CR LF pod LF, a sekwencje wyj¶ciowe LF s± t³umaczone na CR LF. Tryb binarny nie wp³ywa na nic pod Unixem; jednak pod MS-DOS i innymi archaicznymi systemami, mo¿e to byæ niezbêdna w³a¶ciwo¶æ---w przeciwnym wypadku twoja biblioteka C mo¿e zniekszta³ciæ plik. Kluczem do rozró¿niania systemów, które potrzebuj± trybu binarnego od tych, które go nie potrzebuj±, jest ich format pliku tekstowego. Systemy podobne do Unix i Plan9, oddzielaj± linie pojedynczym znakiem i koduj± go w C jako `\n'. Nie potrzebuj± one trybu binarnego. Wszystkie inne potrzebuj±. Je¶li UCHWYTPLIKU jest wyra¿eniem, to warto¶æ brana jest jako nazwa uchwytu pliku.

bless REF,NAZWAKLASY

bless REF

Funkcja ta mówi rzeczy, wskazywanej przez referencjê REF, ¿e jest teraz obiektem w pakiecie NAZWAKLASY---lub w bie¿±cym pakiecie, je¶li nie podano parametru nazwy klasy. Funkcja zwraca dla pewno¶ci referencjê, gdy¿ jest ona czêsto ostatni± rzecz± w konstruktorze. Je¶li b³ogos³awiona funkcja ma byæ dziedziczona w klasach potomnych, to zawsze u¿ywaj wersji dwuargumentowej tej funkcji. Dla dalszych informacji o b³ogos³awieniu obiektów zobacz stronê perlobj(1).

caller WYRA¯

caller

Zwraca kontekst bie¿±cego wywo³ania podprocedury. W kontek¶cie skalarnym, je¶li by³o wywo³anie, tj. je¶li jeste¶my w podprocedurze lub eval() lub require(), zwraca nazwê pakietu wywo³uj±cego, a w przeciwnym razie warto¶æ niezdefiniowan±. W kontek¶cie listowym, zwraca

    ($pakiet, $nazwapliku, $linia) = caller;

Z parametrem WYRA¯ zwraca trochê dodatkowych danych, z których korzysta debugger do drukowania ¶ladu stosu. Warto¶æ WYRA¯ wskazuje, o ile ramek wywo³añ nale¿y siê cofn±æ od bie¿±cej.

    ($pakiet, $nazwapliku, $linia, $podprocedura,

     $maargumenty, $chcetabliê, $teksteval, $jest_require) = caller($i);

$podprocedura tutaj mo¿e byæ "(eval)", je¶li ramka nie jest wywo³aniem podproceduralnym. W tej sytuacji ustawiane s± dodatkowe elementy, $teksteval i $jest_require: $jest_require jest prawdziwe, je¶li ramka zosta³a utworzona w instrukcji require lub use, $teksteval zawiera tekst instrukcji eval WYRA¯. Praktycznie, dla instrukcji eval BLOCK, $nazwapliku to "(eval)", a $teksteval jest niezdefiniowany. (Zauwa¿ te¿, ¿e ka¿da instrukcja use tworzy ramkê require. (wewn±trz ramki eval WYRA¯)

Co wiêcej, po wywo³aniu z pakietu DB, caller zwraca jeszcze dok³adniejsze dane: ustawia zmienn± listow± @DB::args na argumenty, z którymi wywo³ano podprocedurê.

chdir WYRA¯

Zmienia katalog roboczy na WYRA¯. Je¶li WYRA jest pominiête, to zmienia katalog na katalog domowy. Po sukcesie zwraca TRUE, a w przeciwnym wypadku FALSE. Zobacz przyk³ad przy opisie die().

chmod LISTA

Zmienia prawa listy plików. Pierwszy element listy musi byæ numerycznym zapisem praw, który powinien byæ liczb± ósemkow±, a który z pewno¶ci± nie powinien byæ ³añcuchem cyfr ósemkowych: 0644 jest ok, ale '0644' nie jest. Zwraca liczbê plików, których prawa zmieniono. Je¶li wszystkim co masz jest ³añcuch, zobacz te¿ wpis oct, znajduj±cy siê gdzie indziej w tym dokumencie.

    $cnt = chmod 0755, 'foo', 'bar';

    chmod 0755, @executables;

    $mode = '0644'; chmod $mode, 'foo';      # ustawia prawa na --w----r-T!

    $mode = '0644'; chmod oct($mode), 'foo'; # to jest lepsze

    $mode = 0644;   chmod $mode, 'foo';      # to jest najlepsze

chomp ZMIENNA

chomp LISTA

chomp

Jest to troszkê bezpieczniejsza wersja wpisu chop, opisanego gdzie indziej w tym dokumencie. Usuwa wszelkie zakoñczenia linii, które odpowiadaj± bie¿±cej warto¶ci $/ (znanego te¿ jako $INPUT_RECORD_SEPARATOR w module English). Zwraca ca³kowit± liczbê znaków, usuniêtych ze wszystkich argumentów. Czêsto jest u¿ywany do usuwania nowych linii z koñca rekordu wej¶ciowego je¶li obawiasz siê, ¿e rekordowi mo¿e jej brakowaæ. W trybie `paragraph' ($/ = ""), usuwa wszystkie koñcz±ce znaki nowych linii z ³añcuchów. Je¶li pominiêta zostanie ZMIENNA, to ucinane jest $_. Przyk³ad:

    while (<>) {

        chomp;  # zapobiegaj \n na ostatnim polu

        @array = split(/:/);

        ...

    }

Mo¿esz w zasadzie uci±æ wszystko co jest lwarto¶ci±, w³±czaj±c przypisanie:

    chomp($cwd = `pwd`);

    chomp($answer = <STDIN>);

Je¶li ucinasz listê, obcinany jest ka¿dy element, a zwracana jest lista usuniêtych znaków.

chop ZMIENNA

chop LISTA

chop

Odrywa ostatni znak ³añcucha i zwraca jego warto¶æ. Jest przede wszystkim u¿ywany do usuwania nowej linii z koñca rekordu wej¶ciowego, lecz jest du¿o bardziej efektywny ni¿ s/\n//, poniewa¿ ani nie skanuje, ani nie kopiuje ³añcucha. Je¶li pominiêto ZMIENN¡, odrywa $_. Przyk³ad:

    while (<>) {

        chop;   # zapobie¿ \n na ostatnim polu

        @array = split(/:/);

        ...

    }

Mo¿esz w zasadzie oderwaæ cokolwiek, co jest lwarto¶ci±, w³±czaj±c przypisanie:

    chop($cwd = `pwd`);

    chop($answer = <STDIN>);

Je¶li obrywasz listê, obrywany jest ka¿dy element. Zwracana jest tylko warto¶æ ostatniego oderwania.

Zauwa¿, ¿e chop zwraca ostatni znak. Aby zwróciæ wszystkie poza ostatnim, u¿yj substr($lancuch, 0, -1).

chown LISTA

Zmienia w³a¶ciciela (i grupê) listy plików. Pierwsze dwa argumenty listy musz± byæ NUMERYCZNYMI uid i gid, podanym w tej kolejno¶ci. Zwraca liczbê plików, na których powiod³a siê zamiana.

    $cnt = chown $uid, $gid, 'foo', 'bar';

    chown $uid, $gid, @filenames;

Oto przyk³ad, który podgl±da nienumeryczne uid'y w pliku z has³ami:

    print "User: ";

    chop($user = <STDIN>);

    print "Files: "

    chop($pattern = <STDIN>);

    ($login,$pass,$uid,$gid) = getpwnam($user)

        or die "$user not in passwd file";

    @ary = <${pattern}>;        # rozwiñ nazwy plików

    chown $uid, $gid, @ary;

Na wiêkszo¶ci systemów nie mo¿esz zmieniaæ w³a¶cicielstwa, chyba ¿e jeste¶ superu¿ytkownikiem, choæ powiniene¶ byæ w stanie zmieniaæ grupê na dowoln± z twoich drugorzêdnych grup. Na niezabezpieczonych systemach ograniczenia te mog± byæ mniejsze, lecz nie jest to przeno¶ne za³o¿enie.

chr LICZBA

chr

Zwraca znak, reprezentowany przez LICZBÊ w zbiorze znaków. Na przyk³ad, chr(65) to ``A'' w ASCII. Dla odwrócenia tego dzia³ania, u¿yj ord, które jest opisane gdzie indziej w tym dokumencie.

Je¶li pominiêto LICZBÊ, to u¿ywane jest $_.

chroot NAZWAPLIKU

chroot

Funkcja ta dzia³a tak samo jak wywo³anie systemowe chroot(2): powoduje, ¿e podany katalog staje siê nowym katalogiem g³ównym dla wszelkich nowych ¶cie¿ek, które bêd± siê zaczyna³y od ``/''. Tyczy siê to twojego procesu i jego dzieci. Ze wzglêdów bezpieczeñstwa, wywo³anie to jest zastrze¿one dla superu¿ytkownika. Je¶li pominiêto NAZWÊPLIKU, to u¿ywany jest $_.

close UCHWYTPLIKU

Zamyka plik lub potok zwi±zany z uchwytem, zwracaj±c TRUE jedynie w wypadku, gdy stdio da radê opró¿niæ wszystkie bufory i zamkn±æ systemowy deskryptor pliku. Je¶li uchwyt pliku pochodzi³ od otwartego potoku, funkcja zwróci FALSE je¶li które¶ z potrzebnych wywo³añ systemowych zawiedzie lub je¶li program zakoñczy pracê z niezerowym statusem. (Je¶li problemem jest fakt, ¿e program skoñczy³ siê z niezerowym kodem, to $! bêdzie ustawione na 0.) Nie musisz zamykaæ UCHWYTUPLIKU, je¶li chcesz go zaraz potem wykorzystaæ do innego otwarcia open(), poniewa¿ funkcja open() zamknie go za ciebie. Jednak jawne zamkniêcie pliku wej¶ciowego resetuje licznik linii ($.), podczas gdy niejawne zamkniêcie w open() tego nie robi. Poza tym, zamykanie potoku powoduje oczekiwanie na zakoñczenie procesu z potoku, na wypadek gdyby¶ chcia³ pó¼niej obejrzeæ wyj¶cie potoku. Jawne zamykanie potoku wstawia warto¶æ statusu komendy do $?. Przyk³ad:

    open(OUTPUT, '|sort >foo'); # potok do `sort'

    ...                         # drukuj ró¿ne rzeczy na wyj¶cie

    close OUTPUT;               # czekaj na zakoñczenie `sort'

    open(INPUT, 'foo');         # pobierz wyniki sortowania

UCHWYTPLIKU mo¿e byæ wyra¿eniem, którego warto¶æ daje rzeczywist± nazwê uchwytu pliku.

closedir UCHWYTKATALOGU

Zamyka katalog, otworzony funkcj± opendir().

connect GNIAZDO,NAZWA

Próbuje po³±czyæ siê ze zdalnym gniazdem, zupe³nie tak jak wywo³anie systemowe connect(2). Po sukcesie zwraca TRUE, a w przeciwnym wypadku FALSE. NAZWA powinna byæ spakowanym typem adresu, odpowiednim dla gniazda. Zobacz przyk³ady w sekcji Sockets: Client/Server Communication na stronie podrêcznika perlipc(1).

continue BLOK

W rzeczywisto¶ci jest to instrukcja kontroli wykonywania programu, a nie funkcja. Je¶li do BLOKU do³±czone jest continue BLOK (zazwyczaj we while lub foreach), to jest zawsze wykonywany tu¿ przed kolejnym wykonaniem warunku, zupe³nie jak trzecia czê¶æ pêtli for w C. Tak wiêc mo¿e byæ u¿ywane do zwiêkszania zmiennej pêtli, nawet gdy pêtla by³a kontynuowana z pomoc± instrukcji next (która jest podobna do instrukcji continue z C).

cos WYRA¯

Zwraca cosinus z WYRA¯ (wyra¿onego w radianach). Je¶li pominie siê argument WYRA¯, to u¿ywany jest $_.

Dla operacji arcus cosinus, mo¿esz u¿yæ funkcji POSIX::acos(), lub nastêpuj±cej relacji:

    sub acos { atan2( sqrt(1 - $_[0] * $_[0]), $_[0] ) }

crypt CZYSTYTEKST,SALT

Koduje ³añcuch na wzór funkcji crypt(3) z biblioteki C. Mo¿e to byæ u¿yteczne np. do sprawdzania plików z has³ami w poszukiwaniu s³abych hase³. Robiæ to powinni tylko ludzie nosz±cy bia³e kapelusze.

Zauwa¿, ¿e crypt jest funkcjê jednokierunkow±, podobnie jak rozbijanie jajek na omlet. Nie istnieje (znana) funkcja dekoduj±ca. W wyniku, funkcja wcale nie jest tak u¿yteczna do kryptografii. (Dla tego, zobacz najbli¿szy mirror CPAN.)

Oto przyk³ad, który daje pewno¶æ, ¿e ktokolwiek uruchomi ten program, zna swoje w³asne has³o:

    $pwd = (getpwuid($<))[1];

    $salt = substr($pwd, 0, 2);

    system "stty -echo";

    print "Has³o: ";

    chop($word = <STDIN>);

    print "\n";

    system "stty echo";

    if (crypt($word, $salt) ne $pwd) {

        die "Niezmiernie mi przykro...\n";

    } else {

        print "ok\n";

    }

Oczywi¶cie wpisywanie swojego has³a za ka¿dym razem, gdy kto¶ o nie poprosi jest niem±dre.

dbmclose HASH

[Funkcja ta jest przedawniona przez funkcjê untie().]

Przerywa powi±zanie miêdzy plikiem DBM a tablic± asocjacyjn±.

dbmopen HASH,NAZWADB,PRAWA

[funkcja ta jest przedawniona przez funkcjê tie().]

£±czy to plik dbm(3), ndbm(3), sdbm(3), gdbm(), lub Berkeley DB z tablic± asocjacyjn±. HASH jest nazw± tablicy asocjacyjnej. (w przeciwieñstwie do normalnego otwierania, pierwszy argument NIE jest uchwytem pliku, choæ wygl±da podobnie). NAZWADB jest nazw± bazy danych (bez rozszerzeñ w rodzaju .dir czy .pag). Je¶li baza nie istnieje, to jest tworzona z prawami okre¶lanymi przez PRAWA (zmodyfikowanymi przez umask()). Je¶li twój system obs³uguje tylko starsze funkcje DBM, to mo¿esz w swoim programie wykonaæ tylko jeden dbmopen(). W starszych wersjach perla, je¶li system nie mia³ ani DBM, ani ndbm, wywo³anie dbmopen powodowa³o b³±d krytyczny; teraz schodzi do sdbm(3).

Je¶li nie masz prawa zapisu do pliku DBM, to mo¿esz tylko odczytywaæ zmienne asocjacyjne, nie mo¿esz ich ustawiaæ. Je¶li chcesz spróbowaæ, czy mo¿esz zapisywaæ, u¿yj albo testów plikowych, albo spróbuj ustawiæ próbny wpis asocjacyjny wewn±trz eval(), co przechwyci b³±d.

Zauwa¿, ¿e funkcje takie, jak keys() i values() mog± zwracaæ w u¿yciu z plikami DBM wielkie tablice. Mo¿esz do iteracji przez wielkie pliki DBM u¿ywaæ tak¿e each(). Przyk³ad:

    # drukuj offsety pliku historii

    dbmopen(%HIST,'/usr/lib/news/history',0666);

    while (($key,$val) = each %HIST) {

        print $key, ' = ', unpack('L',$val), "\n";

    }

    dbmclose(%HIST);

Zobacz te¿ stronê podrêcznika AnyDBM_File -- jest tam bardziej ogólny opis wad i zalet ró¿nych podej¶æ dbm. Zobacz te¿ stronê DB_File, dla bogatej implementacji.

defined WYRA¯

defined

Zwraca warto¶æ logiczn±, mówi±c± czy WYRA¯ ma warto¶æ inn± od niezdefiniowanej undef. Je¶li WYRA¯ nie jest obecne, to testowane jest $_.

Wiele operacji zwraca undef aby wskazaæ b³±d, koniec pliku, b³±d systemowy, niezainicjalizowan± zmienn± i inne wyj±tki. Funkcja ta pozwala odró¿niæ undef od innych warto¶ci. (Prosty test logiczny nie rozró¿ni undef, zero, pustego ³añcucha, i ``0'', które wszystkie s± jednakowo fa³szywe.) Zauwa¿, ¿e poniewa¿ undef jest prawid³owym skalarem, to jego obecno¶æ niekoniecznie musi wskazywaæ warunek wyj±tkowy: pop() zwraca undef gdy jego argument jest pust± tablic±, lub gdy zwracany element jest warto¶ci± Wundef.

defined() mo¿na u¿ywaæ te¿ do sprawdzania czy podprocedura wychodzi. Z drugiej strony, u¿ywanie defined() na agregatach (tablicach asocjacyjnych i tablicach) nie musi zwróciæ zgodnych z intuicj± wyników i powinno siê go w tych przypadkach unikaæ.

Gdy u¿ywane na elemencie tablicy asocjacyjnej, mówi czy warto¶æ jest zdefiniowana, a nie czy taki klucz istnieje w tablicy. Dla tego celu, u¿yj exists, które jest opisane gdzie indziej w tym dokumencie.

Przyk³ady:

    print if defined $switch{'D'};

    print "$val\n" while defined($val = pop(@ary));

    die "Can't readlink $sym: $!"

        unless defined($value = readlink $sym);

    sub foo { defined &$bar ? &$bar(@_) : die "Brak bar"; }

    $debugging = 0 unless defined $debugging;

Uwaga: Wielu ludzi nadu¿ywa defined(), a potem s± oni zaskoczeni, ¿e liczba 0 i "" (³añcuch o d³ugo¶ci zero) s± w rzeczywisto¶ci warto¶ciami zdefiniowanymi. Na przyk³ad, je¶li powiesz

    "ab" =~ /a(.*)b/;

to porównanie wzorca siê powiedzie i $1 bêdzie zdefiniowane, niezale¿nie od tego, ¿e trafi³o w "nic". W rzeczywisto¶ci nie mo¿na powiedzieæ, ¿e trafi³o w "nic". Raczej trafi³o w co¶, o d³ugo¶ci zera znaków. Jest to wszystko bardzo czyste i uczciwe. Gdy funkcja zwraca warto¶æ niezdefiniowan±, jest to przyznanie siê, ¿e nie mog³a daæ uczciwej odpowiedzi. Tak wiêc powiniene¶ u¿ywaæ defined() tylko je¶li sprawdzasz dzia³anie tego, co próbujesz osi±gn±æ. W niektórych wypadkach, rzecz±, której oczekujesz jest proste porównanie z 0 lub "".

Obecnie u¿ywanie defined() na ca³ej tablicy lub tablicy asocjacyjnej, zg³asza tylko czy zosta³a dla niego zaalokowana pamiêæ. Tak wiêc tablica, któr± ustawiasz na pust± listê jest pocz±tkowo niezdefiniowana, a gdy siê zape³ni, staje siê zdefiniowana. Zamiast tego powiniene¶ u¿yæ prostego testu rozmiaru:

    if (@an_array) { print "ma elementy tablicowe\n" }

    if (%a_hash)   { print "ma elementy asocjacyjne\n"   }

U¿ycie na nich undef() powoduje wyczyszczenie ich pamiêci i zg³oszenie, ¿e nie s± ju¿ zdefiniowane. Nie powinno siê jednak tego robiæ, chyba ¿e nie masz zamiaru ich wiêcej u¿ywaæ, poniewa¿ po prostu szybciej jest u¿ywaæ pamiêci gotowej do wype³nienia, ni¿ alokowaæ j± od nowa.

Zachowanie defined() na agregatach mo¿e zostaæ zmienione, poprawione, lub zepsute w nastêpnych wersjach perla.

Zobacz te¿ opisy undef, exists, i ref, znajduj±ce siê w innych miejscach tego dokumentu.

delete WYRA¯

Kasuje podany klucz(e) i zwi±zane z nim warto¶ci z tablicy asocjacyjnej. Dla ka¿dego klucza, zwracana jest skasowana warto¶æ zwi±zana z kluczem albo warto¶æ niezdefiniowana, je¶li taki klucz nie istnia³. Kasowanie z $ENV{} modyfikuje ¶rodowisko. Kasowanie z tablicy asocjacyjnej, pod³±czonej do pliku DBM, kasuje wpis z pliku. (lecz kasowanie z takiego pliku nie musi zwracaæ niczego.)

Nastêpuj±cy przyk³ad kasuje wszystkie warto¶ci tablicy asocjacyjnej:

    foreach $key (keys %HASH) {

        delete $HASH{$key};

    }

Podobnie robi nastêpuj±ce:

    delete @HASH{keys %HASH}

(Ale obydwa s± wolniejsze ni¿ komenda undef().) Zauwa¿, ¿e WYRA¯ mo¿e byæ arbitralnie skomplikowany tak d³ugo, dopóki koñcowa operacja jest podejrzeniem elementu asocjacyjnego lub wycinkiem tablicy asocjacyjnej (`hash slice'):

    delete $ref->[$x][$y]{$key};

    delete @{$ref->[$x][$y]}{$key1, $key2, @morekeys};

die LISTA

Poza obrêbem eval() drukuje warto¶æ LISTY na STDERR i koñczy pracê z bie¿±c± warto¶ci± $! (errno). Je¶li $! wynosi 0, to koñczy z warto¶ci± ($? >> 8) (status poprzedniej `komendy`). Je¶li ($? >> 8) jest zerem, to koñczy z warto¶ci± 255. Wewn±trz eval, komunikat o b³êdzie jest pakowany do $@, a eval() jest przerywany warto¶ci± niezdefiniowan±; powoduje to, ¿e die() mo¿e podnie¶æ wyj±tek.

Równowa¿ne przyk³ady:

    die "Nie mogê przej¶æ do spool: $!\n" unless chdir '/usr/spool/news';

    chdir '/usr/spool/news' or die "Nie mogê przej¶æ do spool: $!\n"

Je¶li warto¶æ WYRA¯ nie koñczy siê now± lini±, drukowany jest równie¿ numer bie¿±cej linii skryptu i wej¶cia, a za nimi doklejana jest nowa linia. Wskazówka: Czasami dodanie ``, stopped'' do twojego komunikatu mo¿e nadaæ mu wiêcej sensu po doklejeniu ³añcucha ``at foo line 123''. Za³ó¿my, ¿e uruchamiasz skrypt ``canasta''.

    die "/etc/games is no good";

    die "/etc/games is no good, stopped";

daj± w efekcie odpowiednio:

    /etc/games is no good at canasta line 123.

    /etc/games is no good, stopped at canasta line 123.

Zobacz tak¿e exit() i warn().

Mo¿na zaaran¿owaæ sprawê tak, ¿e callback bêdzie wywo³ywany tu¿ przed uczynieniem swojej powinno¶ci przez die(). Nale¿y w tym celu ustawiæ hak $SIG{__DIE__}. Zwi±zany handler zostanie wywo³any z tekstem b³êdu i mo¿e zmieniæ tre¶æ komunikatu b³êdu, wywo³uj±c die() ponownie. Zobacz stronê perlvar(1), dla dalszych detali o ustawianiu wpisów %SIG, a tak¿e opis eval() dla paru przyk³adów.

do BLOK

Nie jest to funkcja. Zwraca warto¶æ ostatniej komendy w sekwencji komend, wskazywanych przez BLOK. Po zmodyfikowaniu przez modyfikator pêtli, wywo³uje jednokrotnie BLOK przed sprawdzeniem warunku pêtli. (W innych instrukcjach modyfikatory pêtli sprawdzaj± warunek na samym pocz±tku.)

do PODPROCEDURA(LISTA)

Niezalecana forma wywo³ania podprocedury. Zobacz stronê perlsub(1).

do WYRA¯

U¿ywa warto¶ci WYRA¯ jako nazwy pliku i wykonuje zawarto¶æ tego pliku jako skrypt perla. Podstawowym zadaniem tej instrukcji jest w³±czanie podprocedur z bibliotek perla.

    do 'stat.pl';

jest zupe³nie jak

    eval `cat stat.pl`;

tylko trochê bardziej efektywne, utrzymuje ¶ledzenie bie¿±cej nazwy plików dla komunikatów o b³êdach i przeszukuje wszystkie katalogi -I, je¶li plik nie znajduje siê w katalogu bie¿±cym (zobacz tak¿e tablicê @INC w sekcji Predefined Names podrêcznika perlvar(1)). Jednak jest takie samo w sensie, ¿e przetwarza (parses) plik za ka¿dym razem, gdy go wywo³asz, wiêc przypuszczalnie nie chcia³by¶ tego wewn±trz pêtli.

Zauwa¿, ¿e w³±czanie modu³ów bibliotecznych mo¿na za³atwiæ lepiej z pomoc± operatorów use() i require(), które równie¿ dokonuj± sprawdzania b³êdów i powoduj± wyj±tki je¶li jest jaki¶ problem.

dump ETYKIETA

Powoduje to natychmiastowy zrzut core. Jest to po to, by¶ móg³ u¿yæ programu undump do konwertowania zrzutu core do pliku binarnego po zainicjalizowaniu wszystkich zmiennych z pocz±tku programu. Po uruchomieniu nowego binarium, rozpocznie siê ono od wywo³ania goto ETYKIETA (ze wszystkimi ograniczeniami, na które cierpi goto). My¶l o tym, jak o goto z interweniuj±cym zrzutem core i reinkarnacj±. Je¶li ETYKIETA jest pominiêta, program restartuje siê od pocz±tku. UWAGA: wszelkie pliki, które by³y otwarte w momencie zrzutu core nie bêd± otwarte w nowej inkarnacji programu, powoduj±c przypuszczalnie zamieszanie w czê¶ci perla. Zobacz te¿ opcjê -u ze strony perlrun(1).

Przyk³ad:

    #!/usr/bin/perl

    require 'getopt.pl';

    require 'stat.pl';

    %days = (

        'Sun' => 1,

        'Mon' => 2,

        'Tue' => 3,

        'Wed' => 4,

        'Thu' => 5,

        'Fri' => 6,

        'Sat' => 7,

    );

    dump QUICKSTART if $ARGV[0] eq '-d';

    QUICKSTART:

    Getopt('f');

each HASH

Po wywo³aniu w kontek¶cie listowym, zwraca dwuelementow± tablicê, sk³adaj±c± siê z klucza i warto¶ci nastêpnego elementu asocjacyjnego, tak ¿e mo¿esz iterowaæ poprzez tablicê. Po wywo³aniu w kontek¶cie skalarnym, zwraca tylko klucz dla nastêpnego elementu asocjacyjnego. (Uwaga: Klucze mog± mieæ warto¶æ "0" lub "", co jest logicznie nieprawid³owe; mo¿esz w tym celu chcieæ zapobiec konstrukcjom jak while ($k = each %foo) {} .)

Wpisy s± zwracane w kolejno¶ci do¶æ losowej. Gdy tablica asocjacyjna jest ca³kowicie odczytana, w kontek¶cie listowym zwracana jest tablica null (co po przypisaniu daje warto¶æ FALSE (0)), a w kontek¶cie skalarnym zwracany jest undef. Nastêpne wywo³anie each() po tym rozpocznie iterowanie od nowa. Dla ka¿dej tablicy asocjacyjnej istnieje pojedynczy iterator, dzielony przez funkcje each(), keys() i values(); mo¿e byæ zresetowany przez odczytanie wszystkich elementów tablicy lub przez wywo³anie keys HASH lub values HASH. Je¶li dodajesz, lub kasujesz elementy tablicy asocjacyjnej podczas jej iterowania, to mo¿e siê zdarzyæ, ¿e niektóre wpisy utracisz, a niektóre dostaniesz zduplikowane. Nie rób wiêc tego.

Nastêpuj±cy przyk³ad drukuje ¶rodowisko, podobnie jak program printenv(1), lecz w odwrotnej kolejno¶ci:

    while (($key,$value) = each %ENV) {

        print "$key=$value\n";

    }

Zobacz te¿ keys() i values().

eof UCHWYTPLIKU

eof ()

eof

Zwraca 1, je¶li nastêpny odczyt z UCHWYTUPLIKU zwróci koniec pliku (eof) lub je¶li UCHWYTPLIKU nie jest otwarty. UCHWYTPLIKU mo¿e byæ wyra¿eniem, którego warto¶æ daje prawdziw± nazwê uchwytu pliku. (Zauwa¿, ¿e ta funkcja w rzeczywisto¶ci odczytuje znak, a potem wstawia go z powrotem, wiêc nie jest zbyt u¿yteczna w kontek¶cie interaktywnym.) Nie czytaj z pliku terminalowego (lub nie wo³aj eof(UCHWYTPLIKU)) po osi±gniêciu koñca pliku. Pliki takie, jak terminale mog± po takim zabiegu utraciæ warunek koñca pliku.

eof bez argumentów, u¿ywa jako argumentu ostatniego odczytu pliku. Puste nawiasy () mog± wskazywaæ na pseudo plik, z³o¿ony z plików, wymienionych w linii komend, np. eof() dobrze jest u¿ywaæ wewn±trz pêtli while (<>), aby wykryæ koniec ostatniego pliku. Przyk³ady:

    # resetuj numerowanie linii dla ka¿dego pliku wej¶ciowego

    while (<>) {

        print "$.\t$_";

        close(ARGV) if (eof);   # Nie eof().

    }

    # wstaw kreski przed ostatni± lini± ostatniego pliku

    while (<>) {

        if (eof()) {

            print "--------------\n";

            close(ARGV);        # close or break; is needed if we

                                # are reading from the terminal

        }

        print;

    }

Wskazówka praktyczna: w perlu prawie nigdy nie trzeba u¿ywaæ eof, poniewa¿ operatory wej¶ciowe zwracaj± undef gdy nie bêd± mia³y wiêcej danych.

eval WYRA¯

eval BLOK

WYRA¯ jest przetwarzany i wykonywany tak, jakby by³ maleñkim programem perla. Jest wywo³ywany w kontek¶cie bie¿±cego programu perla, wiêc wszelkie ustawienia zmiennych lub definicje podprocedur i formatów zostaj± dalej. Zwracana warto¶æ jest warto¶ci± ostatniego wykonanego wyra¿enia, lub warto¶ci±, przekazan± przez return, czyli tak jak w podprocedurach. Ostatnie wyra¿enie jest wykonywane w kontek¶cie skalarnym, lub tablicowym, zale¿nie od kontekstu eval.

Je¶li pojawi siê b³±d sk³adni lub b³±d czasu dzia³ania albo je¶li wykonana zostanie instrukcja die(), to zwrócona zostanie warto¶æ niezdefiniowana, a $@ zostanie ustawione na komunikat o b³êdzie. Je¶li nie by³o b³êdu, $@ bêdzie ³añcuchem null. Je¶li WYRA¯ zostanie pominiête, to wykonywane jest $_. Ostatni ¶rednik, je¶li taki istnieje, mo¿e byæ pominiêty w wyra¿eniu. Ostrzegam jednak, ¿e u¿ywanie eval() nie wycisza perla od drukowania ostrze¿eñ na STDERR, ani nie upycha tekstu tych komunikatów do $@. Aby zrobiæ któr±¶ z tych rzeczy, musisz u¿yæ zabudowania $SIG{__WARN__}. Zobacz warn() i stronê perlvar(1).

Zauwa¿, ¿e poniewa¿ eval() przechwytuje krytyczne (w innych wypadkach) b³êdy, to jest przydatny dla okre¶lania czy konkretna w³a¶ciwo¶æ (taka, jak np. socket(), symlink(), itp. jest zaimplementowana. Jest to równie¿ mechanizm perla obs³ugiwania wyj±tków, gdzie operator die jest mechanizmem ich podnoszenia.

Je¶li wykonywany kod siê nie ró¿ni, mo¿esz u¿yæ postaci eval-BLOK do wychwytywania b³êdów czasu dzia³ania, bez potrzeby rekompilacji za ka¿dym razem. B³±d, je¶li siê pojawi, jest wci±¿ zwracany w $@. Przyk³ady:

    # spowoduj, by dzielenie przez zero nie by³o krytyczne

    eval { $answer = $a / $b; }; warn $@ if $@;

    # to samo, mniej efektywnie

    eval '$answer = $a / $b'; warn $@ if $@;

    # b³±d czasu kompilacji

    eval { $answer = };

    # b³±d czasu dzia³ania

    eval '$answer =';   # ustawia $@

U¿ywaj±c postaci eval{} jako pu³apki na wyj±tki w bibliotekach, mo¿esz nie ¿yczyæ sobie uruchamiania haków __DIE__, które móg³ sobie ustawiæ u¿ytkownik. Dla tego celu mo¿na wykorzystaæ konstrukcjê local $SIG{__DIE__}. Przyk³ad:

    # bardzo prywatna pu³apka na wyj±tek dzielenia przez zero

    eval { local $SIG{'__DIE__'}; $answer = $a / $b; }; warn $@ if $@;

Jest to szczególnie istotne, gdy¿ haki __DIE__ mog± wywo³ywaæ die() ponownie, co ma efekt zmieniania komunikatów o b³êdach:

    # haki __DIE__ mog± modyfikowaæ komunikaty o b³êdach

    {

       local $SIG{'__DIE__'} = sub { (my $x = $_[0]) =~ s/foo/bar/g; die $x };

       eval { die "foo foofs here" };

       print $@ if $@;                # drukuje "bar barfs here"

    }

U¿ywaj±c eval(), powiniene¶ szczególnie uwa¿aæ, by pamiêtaæ na co siê patrzy gdy:

    eval $x;            # PRZYPADEK 1

    eval "$x";          # PRZYPADEK 2

    eval '$x';          # PRZYPADEK 3

    eval { $x };        # PRZYPADEK 4

    eval "\$$x++"       # PRZYPADEK 5

    $$x++;              # PRZYPADEK 6

Przypadki 1 i 2 zachowuj± siê jednakowo: uruchamiaj± kod, zawarty w zmiennej $x. (Chocia¿ przypadek 2 ma og³upiaj±ce cudzys³owy, powoduj±ce, ¿e czytelnik zastanawia siê, co jeszcze mo¿e siê zdarzyæ (nic nie mo¿e).) Przypadki 3 i 4 zachowuj± siê podobnie: wykonuj± one kod `$x', który nie robi nic poza zwróceniem warto¶ci $x. (Przypadek 4 jest preferowany ze wzglêdów estetycznych, ma te¿ zaletê kompilowania podczas kompilacji, a nie podczas dzia³ania.) Przypadek 5 jest miejscem, gdzie normalnie chcia³by¶ u¿yæ cudzys³owów, poza tym, ¿e w tej konkretnej sytuacji mo¿na u¿yæ po prostu symbolicznych referencji. Jest tak w przypadku 6.

exec LISTA

Funkcja exec() wykonuje komendê systemow± i NIGDY NIE POWRACA, chyba ¿e komenda nie istnieje i jest wykonywana bezpo¶rednio, zamiast przez /bin/sh -c (patrz ni¿ej). Je¶li chcesz powróciæ, u¿yj zamiast exec() instrukcji system().

Je¶li w LI¦CIE jest wiêcej ni¿ jeden argument, lub je¶li jest to tablica z wiêcej ni¿ jedn± warto¶ci±, wywo³ywany jest execvp(3) (z argumentami z LISTY). Je¶li jest tylko jeden argument skalarny, to jest on sprawdzany w poszukiwaniu metaznaków pow³oki. Je¶li s± tam jakie¶ znaki, to ca³y argument jest przekazywany do przetworzenia przez /bin/sh -c. Je¶li nie ma ¿adnych metaznaków, to argument jest dzielony na s³owa i przekazywany bezpo¶rednio do execvp(3), co jest bardziej efektywne. Uwaga: exec() i system() nie opró¿niaj± twojego bufora wej¶ciowego, wiêc mo¿liwe, ¿e aby zapobiec utracie wyj¶cia, bêdziesz musia³ ustawiæ $|. Przyk³ady:

    exec '/bin/echo', 'Twoimi argumentami s±: ', @ARGV;

    exec "sort $outfile | uniq";

Je¶li tak naprawdê nie potrzebujesz wywo³aæ pierwszego argumentu, lecz chcesz oszukaæ program, który wykonujesz co do jego nazwy, to mo¿esz podaæ program, który chcesz wywo³aæ jako ``obiekt niebezpo¶redni'' (bez przecinka) na samym pocz±tku LISTY. (Wymusza to zawsze interpretacjê LISTY jako listy wielowarto¶ciowej, nawet je¶li jest tam tylko pojedynczy skalar.) Przyk³ad:

    $shell = '/bin/csh';

    exec $shell '-sh';          # udaj, ¿e to pow³oka loginowa

lub, bardziej bezpo¶rednio,

    exec {'/bin/csh'} '-sh';    # udaj, ¿e to pow³oka loginowy

exists WYRA¯

Zwraca TRUE, je¶li podany klucz asocjacyjny istnieje w tablicy asocjacyjnej. Warto¶æ jest prawdziwa nawet gdy odpowiadaj±ca kluczowi warto¶æ jest niezdefiniowana.

    print "Istnieje\n" if exists $array{$key};

    print "Zdefiniowany\n" if defined $array{$key};

    print "Prawdziwy\n" if $array{$key};

Element asocjacyjny mo¿e byæ prawdziwy tylko wtedy, gdy jest zdefiniowany, a zdefiniowany je¶li istnieje, lecz odwrotna kolejno¶æ niekoniecznie jest prawdziwa.

Zauwa¿, ¿e WYRA¯ mo¿e byæ skomplikowany tak daleko, dopóki ostateczna operacja jest podejrzeniem klucza asocjacyjnego:

    if (exists $ref->[$x][$y]{$key}) { ... }

exit WYRA¯

Wykonuje WYRA¯ i koñczy pracê z t± warto¶ci±. (W rzeczywisto¶ci, wywo³uje najpierw zdefiniowane procedury END, lecz procedury te mog± przerwaæ koñczenie. Podobnie, równie¿ przed wyj¶ciem wo³ane s± wszelkie destruktory obiektów.) Przyk³ad:

    $ans = <STDIN>;

    exit 0 if $ans =~ /^[Xx]/;

Zobacz te¿ die(). Je¶li WYRA¯ jest pominiête, to praca koñczy siê statusem 0. Jedynymi, uniwersalnymi i przeno¶nymi warto¶ciami WYRA¯ s± 0 dla sukcesu i 1 dla b³êdu; wszelkie inne s± podstaw± do dziwnych interpretacji, zale¿nych od ¶rodowiska, w którym program jest uruchomiony.

Nie powiniene¶ u¿ywaæ exit() do przerywania podprocedury, je¶li istnieje szansa, ¿e kto¶ móg³by chcieæ ustawiæ pu³apkê na b³±d. Zamiast tego u¿yj die(), który mo¿e byæ przechwycony przez eval().

exp WYRA¯

exp

Zwraca e (naturalna podstawa logarytmu) do potêgi WYRA¯. Je¶li WYRA¯ jest pominiête, zwraca exp($_).

fcntl UCHWYTPLIKU,FUNKCJA,SKALAR

Implementuje funkcjê fcntl(2). Przypuszczalnie bêdziesz musia³ zaznaczyæ

    use Fcntl;

aby móc siê ni± pos³ugiwaæ. Przetwarzanie argumentów i zwracanie warto¶ci dzia³a zupe³nie jak w ioctl(), opisanym ni¿ej. Zauwa¿, ¿e fcntl() da b³±d krytyczny po u¿yciu na maszynie, nie implementuj±cej fcntl(2). Na przyk³ad:

    use Fcntl;

    fcntl($filehandle, F_GETLK, $packed_return_buffer);

fileno UCHWYTPLIKU

Zwraca deskryptor pliku dla uchwytu pliku. Jest to przydatne dla konstruowania bitmap dla select(). Je¶li UCHWYTPLIKU jest wyra¿eniem, to jego warto¶æ brana jest za nazwê uchwytu pliku.

flock UCHWYTPLIKU,OPERACJA

Wywo³uje flock(2), lub emuluje go dla uchwytu UCHWYTPLIKU. Zwraca TRUE po sukcesie, FALSE w wypadku jakiego¶ problemu. Na maszynach nie implementuj±cych blokowania flock(2), fcntl(2), lub lockf(3), powoduje b³±d krytyczny. flock() jest przeno¶nym perlowym interfejsem blokowania plików, choæ blokuje tylko ca³e pliki, a nie rekordy.

OPERACJA jest jedn± z LOCK_SH, LOCK_EX, lub LOCK_UN. Mo¿liwa jest jeszcze kombinacja z LOCK_NB. Sta³e te maj± tradycyjne warto¶ci 1, 2, 8 i 4, lecz mo¿esz u¿ywaæ nazw symbolicznych po zaimportowaniu ich z modu³u Fcntl, robi±c to albo pojedynczo, albo grupowo, u¿ywaj±c tagu `:flock' . LOCK_SH ¿±da blokady dzielonej, LOCK_EX ¿±da blokady na wy³±czno¶æ, a LOCK_UN zwalnia poprzednio za¿±dan± blokadê. Je¶li do LOCK_SH lub LOCK_EX dodany zostanie LOCK_NB, to flock nie bêdzie blokowa³, oczekuj±c na zablokowanie, lecz zakoñczy dzia³anie natychmiast (aby dowiedzieæ siê, czy uzyska³e¶ blokadê, sprawd¼ status wyj¶cia).

Aby zapobiec prawdopodobnie dekoordynacji, perl opró¿nia UCHWYTPLIKU przed jego (od)blokowaniem.

Zauwa¿, ¿e emulacja zbudowana za pomoc± lockf(3) nie daje blokad dzielonych i wymaga, by UCHWYTPLIKU by³ otwarty z zamiarem zapisu. Jest to semantyka, któr± implementuje lockf(3). Wiêkszo¶æ (wszystkie?) systemów jednak implementuje lockf(3) na zasadach blokowania fcntl(2), wiêcej ró¿nice nie powinny siê dawaæ we znaki.

Zauwa¿ te¿, ¿e niektóre wersje flock() nie mog± blokowaæ rzeczy poprzez sieæ; bêdziesz musia³ u¿yæ do tego bardziej specyficznego dla systemu fcntl(). Je¶li chcesz, mo¿esz zmusiæ perla do ignorowania systemowej funkcji flock(2) i u¿ywaæ jego w³asnej, opartej o fcntl(2) emulacji. Robi siê to, podaj±c programowi Configure prze³±cznik -Ud_flock. Trzeba to oczywi¶cie zrobiæ podczas konfigurowania perla jako takiego.

Oto doklejacz mailboxa dla systemów BSD.

    use Fcntl ':flock'; # importuj sta³e LOCK_*

    sub lock {

        flock(MBOX,LOCK_EX);

        # a w wypadku, gdyby kto¶ doklei³

        # podczas naszego oczekiwania...

        seek(MBOX, 0, 2);

    }

    sub unlock {

        flock(MBOX,LOCK_UN);

    }

    open(MBOX, ">>/usr/spool/mail/$ENV{'USER'}")

            or die "Nie mogê otworzyæ mailboxa!: $!";

    lock();

    print MBOX $msg,"\n\n";

    unlock();

Zobacz te¿ stronê podrêcznika. S± tam inne przyk³ady flock().

fork

Wykonuje wywo³anie systemowe fork(2). Zwraca procesowi rodzicielskiemu pid dziecka, a w w±tku dziecka zwraca zero. W wypadku b³êdu, zwraca undef. Uwaga: nieopró¿nione bufory pozostaj± nieopró¿nione w obydwu procesach, co znaczy, ¿e bêdziesz musia³ ustawiæ $| ($AUTOFLUSH w English) lub wywo³aæ metodê autoflush() z IO::Handle aby zapobiec duplikacji wyj¶cia.

Je¶li fork()'ujesz bez czekania na dzieci, zbierzesz zombies. (Osierocone procesy.)

    $SIG{CHLD} = sub { wait };

Istnieje te¿ trik podwójnego forka (sprawdzanie b³êdów forka zosta³o pominiête);

    unless ($pid = fork) {

        unless (fork) {

            exec "co naprawdê chcesz robiæ";

            die "bez exec";

            # ... or ...

            ## (jaki¶_kod_perla)

            exit 0;

        }

        exit 0;

    }

    waitpid($pid,0);

Zobacz te¿ stronê podrêcznika perlipc(1). S± tam dalsze przyk³ady forkowania i zbierania konaj±cych dzieci.

Zauwa¿, ¿e je¶li twoje forkowane dziecko dziedziczy systemowe deskryptory plików, takie jak STDIN i STDOUT, które w rzeczywisto¶ci s± po³±czone potokiem lub gniazdem, to je¶li skoñczysz dzia³anie, zdalny serwer (taki jak httpd, rsh) nie bêdzie my¶la³, ¿e rzeczywi¶cie skoñczy³e¶. Powiniene¶ je otworzyæ na nowo na /dev/null.

format

Zadeklaruj format obrazka, u¿ywanego z funkcj± write(). Na przyk³ad:

    format Something =

        Test: @<<<<<<<< @||||| @>>>>>

              $str,     $%,    '$' . int($num)

    .

    $str = "widget";

    $num = $cost/$quantity;

    $~ = 'Something';

    write;

Dla dalszych opisów i przyk³adów, zobacz stronê perlform(1).

formline OBRAZEK,LISTA

Jest to funkcja wewnêtrzna, u¿ywana przez formaty. Mo¿na j± jednak wywo³aæ te¿ samodzielnie. Formatuje ona (zobacz stronê perlform(1)) listê warto¶ci zale¿nie od zawarto¶ci OBRAZKA, umieszczaj±c wyj¶cie w akumulatorze wyj¶cia formatowego, $^A ($ACCUMULATOR w English). Ostatecznie, po dokonaniu write(), zawarto¶æ $^A jest zapisywana do jakiego¶ uchwytu pliku. Mo¿esz jednak odczytaæ go samodzielnie i ustawiæ na "". Zauwa¿, ¿e format zazwyczaj wykonuje jeden formline() na ka¿d± liniê formy, lecz sama funkcja fromline nie zwraca uwagi na to, ile nowych linii jest osadzonych w OBRAZKU. Znaczy to, ¿e tokeny ~ i ~~ bêd± traktowaæ ca³y OBRAZEK jako liniê pojedyncz±. Mo¿esz wiêc byæ zmuszonym do u¿ywania wielu linii form, aby zaimplementowaæ pojedynczy format zapisu, podobnie jak kompilator format.

Uwa¿aj, je¶li wstawiasz wokó³ obrazka podwójne cudzys³owy--znak ``@'' mo¿e byæ wziêty za pocz±tek nazwy tablicy. formline() zawsze zwraca TRUE. Zobacz stronê perlform(1) dla dalszych przyk³adów.

getc UCHWYTPLIKU

getc

Zwraca nastêpny znak z pliku wej¶ciowego, identyfikowanego przez UCHWYTPLIKU. Na koñcu pliku zwraca ³añcuch null. Je¶li UCHWYTPLIKU zostanie pominiêty, odczyt nastêpuje ze STDIN. Nie jest to efektywne. Nie mo¿e byæ u¿ywane do pobierania niebuforowanych pojedynczych znaków. Do tego celu spróbuj raczej czego¶ w rodzaju:

    if ($BSD_STYLE) {

        system "stty cbreak </dev/tty >/dev/tty 2>&1";

    }

    else {

        system "stty", '-icanon', 'eol', "\001";

    }

    $key = getc(STDIN);

    if ($BSD_STYLE) {

        system "stty -cbreak </dev/tty >/dev/tty 2>&1";

    }

    else {

        system "stty", 'icanon', 'eol', '^@'; # ASCII null

    }

    print "\n";

Okre¶lenie, czy $BSD_STYLE powinno byæ ustawione, pozostawiamy jako æwiczenie dla czytelnika.

Na systemach, kompatybilnych z POSIX, bardziej przeno¶na do tego celu mo¿e byæ funkcja POSIX::getattr(). Zobacz te¿ modu³ Term::ReadKey z najbli¿szego mirrora CPAN; szczegó³y o CPAN mo¿na znale¼æ we wpisie CPAN ze strony podrêcznika perlmod(1).

getlogin

Zwraca bie¿±cy login z /etc/utmp. (o ile istnieje.) W wypadku nulla, u¿yj getpwuid().

    $login = getlogin || getpwuid($<) || "Kilroy";

Nie wykorzystuj getlogin() do autentykacji: nie jest tak bezpieczny jak getpwuid().

getpeername GNIZADO

Zwraca spakowany adres sockaddr drugiego koñca z po³±czenia na GNIE¬DZIE.

    use Socket;

    $hersockaddr    = getpeername(SOCK);

    ($port, $iaddr) = unpack_sockaddr_in($hersockaddr);

    $herhostname    = gethostbyaddr($iaddr, AF_INET);

    $herstraddr     = inet_ntoa($iaddr);

getpgrp PID

Zwraca bie¿±c± grupê procesu dla podanego PIDa. Aby uzyskaæ grupê bie¿±cego procesu, u¿yj warto¶ci PID równej zero. U¿ycie tej funkcji na maszynie, nie implementuj±cej getpgrp(2) podniesie wyj±tek. Je¶li parametr PID zostanie pominiêty, to zwracana jest grupa bie¿±cego procesu. Zauwa¿, ¿e wersja POSIX getpgrp nie przyjmuje argumentu PID, wiêc naprawdê przeno¶na jest tylko konstrukcja PID==0.

getppid

Zwraca identyfikator procesu rodzicielskiego.

getpriority CZYJE,KTO

Zwraca bie¿±cy priorytet procesu, grupy procesów, lub u¿ytkownika. (Zobacz stronê podrêcznika getpriority(2).) U¿ycie tej funkcji na maszynie nie implementuj±cej getpriority(2) podniesie wyj±tek krytyczny.

getpwnam NAZWA

getgrnam NAZWA

gethostbyname NAZWA

getnetbyname NAZWA

getprotobyname NAZWA

getpwuid UID

getgrgid GID

getservbyname NAZWA,PROTO

gethostbyaddr ADR,TYPADRESU

getnetbyaddr ADR,TYPADRESU

getprotobynumber LICZBA

getservbyport PORT,PROTO

getpwent

getgrent

gethostent

getnetent

getprotoent

getservent

setpwent

setgrent

sethostent STAYOPEN

setnetent STAYOPEN

setprotoent STAYOPEN

setservent STAYOPEN

endpwent

endgrent

endhostent

endnetent

endprotoent

endservent

Funkcje te dokonuj± tych samych akcji, co ich odpowiedniki z biblioteki systemowej. W kontek¶cie listowym, warto¶ci zwracane ró¿nych funkcji `get' s± nastêpuj±ce:

    ($nazwa,$has³o,$uid,$gid,

       $quota,$komentarz,$gcos,$katalog,$shell) = getpw*

    ($nazwa,$has³o,$gid,$cz³onkowie) = getgr*

    ($nazwa,$aliasy,$typadresu,$d³ugo¶æ,@addrs) = gethost*

    ($nazwa,$aliasy,$typadresu,$sieæ) = getnet*

    ($nazwa,$aliasy,$protokó³) = getproto*

    ($nazwa,$aliasy,$port,$protokó³) = getserv*

(Je¶li wpis nie istnieje, dostaniesz listê null.)

W kontek¶cie skalarnym, dostajesz nazwê. Wyj±tkiem jest funkcja podgl±dania wed³ug nazwy, gdzie dostajesz inn± rzecz, jak± by ona nie by³a. (Je¶li wpis nie istnieje, otrzymujesz warto¶æ niezdefiniowan±.) Na przyk³ad:

    $uid = getpwnam

    $nazwa = getpwuid

    $nazwa = getpwent

    $gid = getgrnam

    $nazwa = getgrgid

    $nazwa = getgrent

    itd.

Warto¶æ $cz³onkowie, zwracana przez getgr*() to oddzielona spacjami lista nazw loginowych cz³onków grupy.

Je¶li w C obs³ugiwana jest zmienna errno, to dla funkcji gethost*() jego warto¶æ bêdzie przekazywana przez $?. Warto¶æ @addrs, zwracana przez wykonane wywo³anie, jest list± czystych (raw) adresów, zwróconych przez odpowiednie wywo³anie systemowe. W domenie internetowej, ka¿dy adres jest czterobajtowy, a rozpakowaæ go mo¿esz, mówi±c co¶ w rodzaju:

    ($a,$b,$c,$d) = unpack('C4',$addr[0]);

getsockname GNIAZDO

Zwraca spakowany adres sockaddr tego koñca po³±czenia na GNIE¬DZIE.

    use Socket;

    $mysockaddr = getsockname(SOCK);

    ($port, $myaddr) = unpack_sockaddr_in($mysockaddr);

getsockopt GNIAZDO,POZIOM,NAZWAOPCJI

Zwraca za¿±dan± opcjê gniazda, lub warto¶æ niezdefiniowan± w wypadku b³êdu.

glob WYRA¯

glob

Zwraca warto¶æ WYRA¯ z rozwiniêciami nazwy plików, takimi jakich dokona³aby pow³oka. Funkcja ta jest wewnêtrzn± funkcj± implementuj±c± operator <*.c>, lecz mo¿esz jej u¿yæ bezpo¶rednio. Je¶li pominiête zostanie WYRA¯, to u¿ywane bêdzie $_. Operator <*.c> jest omówiony bli¿ej w sekcji I/O Operators na stronie perlop(1).

gmtime WYRA¯

Konwertuje czas zwrócony przez funkcjê time do 9 elementowej tablicy, w której znajduje siê czas zlokalizowany do standardowej strefy Greenwich. Zazwyczaj jest to u¿ywane nastêpuj±co:

    #  0    1    2     3     4    5     6     7     8

    ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =

                                            gmtime(time);

Wszystkie elementy tablicy s± numeryczne i pochodz± wprost ze struktury tm. Ogólnie znaczy to, ¿e $mon ma zakres 0..11, a $wday 0..6, z niedziel± kryj±c± siê pod 0. Dodatkowo, $year jest liczb± lat od 1900, a nie po prostu dwiema ostatnimi cyframi roku.

Je¶li WYRA¯ jest pominiête, wykonuje gmtime(time()).

W kontek¶cie skalarnym, zwraca warto¶æ ctime(3):

    $now_string = gmtime;  # np. "Thu Oct 13 04:54:34 1994"

Zobacz te¿ funkcjê timegm(), udostêpnian± przez modu³ Time::Local, a tak¿e funkcjê strftime(3), dostêpn± przez modu³ POSIX.

goto ETYKIETA

goto WYRA¯

goto &NAZWA

Postaæ goto-ETYKIETA szuka instrukcji, oznaczonej przez ETYKIETA i kontynuuje dzia³anie od tamtego miejsca. Nie mo¿e byæ u¿ywane do przechodzenia do konstrukcji, wymagaj±cej inicjalizacji, takiej jak podprocedura czy pêtla foreach. Nie mo¿e te¿ byæ u¿ywane do przechodzenia do konstrukcji optymalizowanej, lub do wychodzenia z bloku, lub podprocedury, przekazanej do sort(). Mo¿na nim natomiast przeskoczyæ prawie we wszystkie inne miejsca zakresu dynamicznego, w³±czaj±c wychodzenie z podprocedur, choæ w tym wypadku lepiej u¿yæ innej konstrukcji, takiej jak last lub die. Autor perla nigdy nie czu³ potrzeby u¿ywania tej postaci goto (tzn. w perlu---C jest inn± spraw±).

Postaæ goto-WYRA¯ oczekuje nazwy etykiety, której zakres mo¿e byæ rozwi±zany dynamicznie. Pozwala to na obliczane goto per FORTRAN, lecz nie jest zbyt zalecane, je¶li optymalizujesz ze wzglêdu na ³atwo¶æ konserwacji programu:

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

Postaæ goto-&NAZWA jest bardzo magiczna i podmienia wywo³anie do nazwanej podprocedury dla bie¿±cej procedury. Jest to u¿ywane przez podprocedury AUTOLOAD, które chc± ³adowaæ inne podprocedury, a potem udawaæ, ¿e ta inna podprocedura zosta³a wywo³ana jako pierwsza (poza tym, wszelkie zmiany @_ bie¿±cej podprocedury s± przekazywane innej podprocedurze.) Po tym goto, nawet caller() nie bêdzie w stanie powiedzieæ, ¿e ta procedura by³a wywo³ana pierwsza.

grep BLOK LISTA

grep WYRA¯,LISTA

Jest to podobne duchowo, lecz nie identyczne do grep(1) i krewnych. W rzeczywisto¶ci, nie jest ograniczone do u¿ywania wyra¿eñ regularnych.

Wykonuje BLOK lub WYRA¯ dla ka¿dego elementu LISTY (ustawiaj±c lokalnie $_ na ka¿dy element) i zwracaj±c listê warto¶ci, sk³adaj±cych siê z tych, dla których wykonane wyra¿enie by³o prawdziwe. W kontek¶cie skalarnym, zwraca liczbê prawdziwych wyra¿eñ.

    @foo = grep(!/^#/, @bar);    # Pozb±d¼ siê komentarzy

lub równowa¿nie,

    @foo = grep {!/^#/} @bar;    # pozb±d¼ siê komentarzy

Zauwa¿, ¿e skoro $_ jest referencj± do warto¶ci listy, mo¿e byæ u¿ywane do modyfikowania elementów tablicy. Podczas gdy jest to przydatne i obs³ugiwane, mo¿e to spowodowaæ te¿ nieoczekiwane rezultaty, szczególnie w wypadku gdy LISTA nie jest nazwan± tablic±.

Grep zwraca aliasy do oryginalnej listy. Znaczy to, ¿e modyfikowanie elementu listy zwróconej przez to polecenie, modyfikuje te¿ element listy oryginalnej.

hex WYRA¯

hex

Interpretuje WYRA¯ jako ³añcuch szesnastkowy i zwraca odpowiadaj±c± mu warto¶æ. (Dla konwersji ³añcuchów, które mog± siê zaczynaæ od 0, lub 0x, zobacz opis oct, znajduj±cy siê gdzie¶ w tym dokumencie.) Je¶li WYRA¯ zostanie pominiête, to u¿ywane jest $_.

    print hex '0xAf'; # drukuje '175'

    print hex 'aF';   # to samo

import

Nie istnieje wbudowana funkcja import. Jest to zwyczajna metoda (podprocedura), definiowana (dziedziczona) przez modu³y, które ¿ycz± sobie eksportowaæ nazwy do kolejnych modu³ów. [potem] funkcja use() wo³a metodê import() dla u¿ywanego pakietu. Zobacz jeszcze opis use() i stronê perlmod(1) oraz stronê Exporter.

index STR,SUBSTR,POZYCJA

index STR,SUBSTR

Zwraca pozycjê pierwszego pojawienia siê SUBSTR w ³añcuchu STR. Je¶li POZYCJA jest pominiêta, to przeszukiwanie rozpoczyna siê od pocz±tku ³añcucha. Warto¶æ zwracana jest oparta o 0 (lub tego, na co ustawisz zmienn± $[ ---lecz lepiej tego nie rób). Je¶li podci±g nie mo¿e zostaæ zlokalizowany, zwracana jest podstawa - 1, czyli normalnie -1.

int WYRA¯

int

Zwraca czê¶æ ca³kowit± z WYRA¯. Je¶li WYRA¯ jest pominiête, u¿ywane jest $_.

ioctl UCHWYTPLIKU,FUNKCJA,SKALAR

Implementuje funkcjê ioctl(2). Przypuszczalnie aby jej u¿ywaæ, bêdziesz musia³ powiedzieæ

    require "ioctl.ph"; # przypuszczalnie w /usr/local/lib/perl/ioctl.ph

Je¶li ioctl.ph nie istnieje, lub nie ma w³a¶ciwych definicji, bêdziesz musia³ u¿yæ swojej w³asnej, opartej na nag³ówkach C, takich jak <sys/ioctl.h>. (Istnieje skrypt perla o nazwie h2ph(1), która pomaga w konwersji, lecz jest to nietrywialna sprawa.) SKALAR jest warto¶ci± zapisywan±, lub odczytywan±, zale¿nie od FUNKCJI---wska¼nik do warto¶ci ³añcuchowej SKALARA bêdzie przekazany jako trzeci argument w³a¶ciwego wywo³ania ioctl. (Je¶li SKALAR nie ma warto¶ci ³añcuchowej, lecz ma numeryczn±, to zostanie przekazana ta warto¶æ zamiast wska¼nika do ³añcucha. Aby zapewniæ, ¿e bêdzie to prawdziwe, przed u¿yciem dodaj do skalara 0). Do manipulowania na warto¶ciach struktur, u¿ywanych przez ioctl() przydatne s± funkcje pack() i unpack(). Nastêpuj±cy przyk³ad ustawia znak kasowania na DEL.

    require 'ioctl.ph';

    $getp = &TIOCGETP;

    die "NO TIOCGETP" if $@ || !$getp;

    $sgttyb_t = "ccccs";                # 4 znaki i short

    if (ioctl(STDIN,$getp,$sgttyb)) {

        @ary = unpack($sgttyb_t,$sgttyb);

        $ary[2] = 127;

        $sgttyb = pack($sgttyb_t,@ary);

        ioctl(STDIN,&TIOCSETP,$sgttyb)

            || die "Nie mogê wykonaæ ioctl: $!";

    }

Warto¶æ zwracana ioctl (i fcntl) jest nastêpuj±ca:

        gdy OS zwraca:          to Perl zwraca:

            -1               warto¶æ niezdefiniowan±

             0                ³añcuch "0 but true"

         co¶ innego                 to samo

Tak wiêc, mimo ¿e perl zwraca po sukcesie TRUE, a w wypadku niepowodzenia FALSE, mo¿esz ³atwo okre¶liæ rzeczywist± warto¶æ zwrócon± przez system operacyjny:

    ($retval = ioctl(...)) || ($retval = -1);

    printf "System zwróci³ %d\n", $retval;

join WYRA¯,LISTA

£±czy osobne ³añcuchy LISTY w pojedynczy ³añcuch, w którym pola s± rozdzielone warto¶ciami WYRA¯. Zwraca ten ³añcuch. Przyk³ad:

    $_ = join(':', $login,$passwd,$uid,$gid,$gcos,$home,$shell);

Zobacz te¿ opis split.

keys HASH

Zwraca normalna tablicê, sk³adaj±c± siê z wszystkich kluczy nazwanej tablicy asocjacyjnej. (W kontek¶cie skalarnym, zwraca liczbê kluczy.) Klucze s± zwracane w do¶æ losowej kolejno¶ci, lecz w tej samej, w której swoje warto¶ci produkuj± funkcje values() i each() (o ile tablica asocjacyjna nie by³a [w miêdzyczasie] zmieniana). W efekcie ubocznym, funkcja resetuje iterator tablicy.

A oto jeszcze inny sposób na wydrukowanie ¶rodowiska:

    @keys = keys %ENV;

    @values = values %ENV;

    while ($#keys >= 0) {

        print pop(@keys), '=', pop(@values), "\n";

    }

a co, je¶li by je posortowaæ wed³ug klucza:

    foreach $key (sort(keys %ENV)) {

        print $key, '=', $ENV{$key}, "\n";

    }

Aby posortowaæ tablicê wed³ug warto¶ci, bêdziesz musia³ u¿yæ funkcji sort. Oto numeryczne posortowanie tablicy asocjacyjnej wed³ug jej warto¶ci:

    foreach $key (sort { $hash{$b} <=> $hash{$a} } keys %hash)) {

        printf "%4d %s\n", $hash{$key}, $key;

    }

Jako lwarto¶æ, keys umo¿liwia zwiêkszanie liczby komórek asocjacyjnych, zaalokowanych dla danej tablicy asocjacyjnej. Mo¿esz zyskaæ na efektywno¶ci, je¶li tablica ma byæ du¿a. (Jest to podobne do pre-rozszerzania tablicy przez przeznaczanie $#array wiêkszego numeru.) Je¶li powiesz

    keys %hash = 200;

to %hash bêdzie mia³ co najmniej 200 zaalokowanych komórek. Komórki te bêd± utrzymywane nawet, je¶li zrobisz %hash = (). Je¶li chcesz zwolniæ zasób wewn±trz zakresu, u¿yj undef %hash. Korzystaj±c z powy¿szej w³a¶ciwo¶ci, zawsze mo¿na zmniejszyæ liczbê zaalokowanych komórek.

kill LISTA

Wysy³a sygna³ do listy procesów. Pierwszy element listy musi byæ nazw± sygna³u. Zwraca liczbê procesów, do których uda³o siê przes³aæ sygna³.

    $cnt = kill 1, $child1, $child2;

    kill 9, @goners;

W przeciwieñstwie do zachowania w pow³oce, w perlu je¶li -1SYGNA£ jest ujemny, to killuje grupy procesów, zamiast procesów. (W Systemie V, ujemny numer PROCESU odnosi siê te¿ do grup procesów, lecz nie jest to przeno¶ne.) Oznacza to, ¿e zazwyczaj chcesz przekazywaæ sygna³y dodatnie. Mo¿esz te¿ u¿ywaæ nazw sygna³ów w cudzys³owach. Zobacz jeszcze sekcjê Signals w podrêczniku perlipc(1).

last ETYKIETA

last

Komenda last jest podobna do instrukcji break z C (u¿ywanej w pêtlach); przerywa natychmiastowo pêtlê. Je¶li pominiêty jest parametr ETYKIETY, to komenda odnosi siê do najbardziej wewnêtrznej pêtli zamykaj±cej. Potencjalna instrukcja bloku continue nie jest wykonywana:

    LINE: while (<STDIN>) {

        last LINE if /^$/;      # zakoñcz po skoñczeniu z nag³ówkiem

        ...

    }

lc WYRA¯

lc

Zwraca WYRA¯ w ma³ych literach. Jest to wewnêtrzna funkcja, implementuj±ca escape \L w ³añcuchach ujêtych w cudzys³owy. Je¶li w³±czone jest use locale, to szanuje bie¿±ce locale LC_CTYPE. Zobacz stronê podrêcznika perllocale(1).

Je¶li WYRA¯ jest pominiête, u¿ywane jest $_.

lcfirst WYRA¯

lcfirst

Zwraca warto¶æ WYRA¯, w którym pierwszy znak jest zast±piony ma³± liter±. Jest to funkcja wewnêtrzna, implementuj±ca escape \l w ³añcuchach ujêtych w podwójne cudzys³owy. Je¶li w³±czone jest use locale, to szanuje bie¿±ce locale LC_CTYPE. Zobacz stronê podrêcznika perllocale(1).

Je¶li WYRA¯ jest pominiête, u¿ywane jest $_.

length WYRA¯

length

Zwraca d³ugo¶æ w znakach warto¶ci WYRA¯. Je¶li WYRA¯ jest pominiête, zwracana jest d³ugo¶æ $_.

link STARYPLIK,NOWYPLIK

Tworzy now± nazwê pliku, dowi±zan± do starej nazwy pliku. Po sukcesie zwraca 1, a w przeciwnym wypadku 0.

listen GNIAZDO,ROZMIARKOLEJKI

Robi to samo, co wywo³anie systemowe listen(2). Zwraca TRUE po sukcesie, a w przeciwnym wypadku FALSE. Zobacz przyk³ad w sekcji Sockets: Client/Server Communication w podrêczniku perlipc(1).

local WYRA¯

Local modyfikuje wymienione zmienne tak, ¿e s± lokalne w otaczaj±cym je bloku, podprocedurze, eval{}, lub do. Je¶li wymieniona jest wiêcej ni¿ jedna warto¶æ, to lista musi byæ umieszczona w nawiasach. Zobacz sekcjê Temporary Values via local() w podrêczniku perlsub(1).

Zamiast local(), czêsto raczej wola³by¶ u¿yæ my(), gdy¿ to pierwsze tak naprawdê nie jest tym czym siê wiêkszo¶ci ludzi wydaje. Odsy³am do sekcji Private Variables via my() w podrêczniku perlsub(1).

localtime WYRA¯

Konwertuje czas, zwrócony przez funkcjê time na 9-elementow± tablicê, której czas jest zanalizowany dla lokalnej strefy czasowej. Zazwyczaj jest to u¿ywane nastêpuj±co:

    #  0    1    2     3     4    5     6     7     8

    ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =

                                                localtime(time);

Wszystkie elementy tablicy s± numeryczne i pochodz± wprost ze struktury tm. W rzeczywisto¶ci znaczy to, ¿e $mon ma zasiêg 0..11, a $wday 0..6, gdzie 0 oznacza niedzielê. Poza tym, $year jest liczb± lat ot 1900 roku, tj. rok 123 oznacza 2023.

Je¶li WYRA¯ zostanie pominiête, to u¿ywany jest czas bie¿±cy (localtime(time)).

W kontek¶cie skalarnym, zwraca warto¶æ ctime(3):

    $now_string = localtime;  # np., "Thu Oct 13 04:54:34 1994"

Zobacz te¿ modu³ Time::Local i funkcje strftime(3) i mktime(3), dostêpne przez modu³ POSIX.

log WYRA¯

log

Zwraca logarytm (podstawa e) z WYRA¯. Je¶li WYRA¯ jest pominiête, zwraca warto¶æ dla $_.

lstat UCHWYTPLIKU

lstat WYRA¯

lstat

Robi to samo, co funkcja stat(), lecz zamiast plików, na które wskazuj± dowi±zania symboliczne, testuje same dowi±zania. Je¶li twój system nie obs³uguje dowi±zañ symbolicznych, dokonywany jest zwyk³y stat().

Je¶li WYRA¯ jest pominiête, u¿ywane jest $_.

m//

Operator porównania. Zobacz stronê perlop(1).

map BLOK LISTA

map WYRA¯,LISTA

Analizuje BLOK lub WYRA¯ dla ka¿dego elementu LISTY (ustawiaj±c lokalnie $_ na ka¿dy element) i zwraca warto¶æ listow±, z³o¿on± z wyników ka¿dego analizowania. BLOK lub WYRA¯ jest analizowany w kontek¶cie listowym, wiêc ka¿dy element LISTY mo¿e daæ zero, jeden, lub wiêcej elementów w warto¶ci zwracanej.

    @chars = map(chr, @nums);

t³umaczy listê liczb na odpowiadaj±ce im znaki. A

    %hash = map { getkey($_) => $_ } @array;

jest tylko ¶miesznym sposobem zapisania

    %hash = ();

    foreach $_ (@array) {

        $hash{getkey($_)} = $_;

    }

mkdir NAZWAPLIKU,PRAWA

Tworzy katalog, podany jako NAZWAPLIKU, którego prawa s± okre¶lone przez PRAWA (zmodyfikowane przez umaskê). Je¶li operacja zakoñczy siê sukcesem, zwraca 1, w przeciwnym wypadku zwraca 0 i ustawia $! (errno).

msgctl ID,CMD,ARG

Wo³a funkcjê IPC msgctl(2) z Systemu V. Je¶li CMd jest &IPC_STAT, to ARG musi byæ zmienn±, która bêdzie przechowywaæ zwrócon± strukturê msquid_ds. Warto¶æ zwracana tej funkcji jest podobna do ioctl: dla b³êdu warto¶æ niezdefiniowana, ``0 but true'' dla zera, oraz rzeczywista warto¶æ zwracana dla innych wypadków.

msgget KLUCZ,FLAGI

Wo³a funkcjê IPC msgget(2) z Systemu V. Zwraca identyfikator kolejki komunikatów, lub warto¶æ niezdefiniowan± (w wypadku b³êdu).

msgsnd ID,MSG,FLAGI

Wo³a funkcjê IPC msgsnd(2) z Systemu V, która przesy³a komunikat MSG do kolejki komunikatów ID. MSG musi zaczynaæ siê warto¶ci± long int, okre¶laj±c± typ, któr± mo¿na utworzyæ z pomoc± pack("l",$typ). Zwraca TRUE po sukcesie i FALSE w wypadku b³êdu.

msgrcv ID,VAR,ROZMIAR,TYP,FLAGI

Wo³a funkcjê IPC msgrcv(2) z Systemu V. Funkcja odbiera komunikat z kolejki komunikatów ID i zapisuje go do zmiennej VAR. Maksymalna odbierana wiadomo¶æ ma wielko¶æ ROZMIAR. Zauwa¿, ¿e gdy wiadomo¶æ jest odbierana, to jej typ bêdzie pierwsz± rzecz±, l±duj±c± w VAR, a maksymalna d³ugo¶æ VAR to ROZMIAR plus rozmiar typu komunikatu. Zwraca TRUE po sukcesie, a FALSE w wypadku b³êdu. [przyp.t³um.: pole TYPE generalnie w IPC oznacza typ, zdefiniowany w pierwszych 4 bajtach komunikatu]

my WYRA¯

Instrukcja ``my'' deklaruje wymienione zmienne jako lokalne dla zamkniêtego bloku, podprocedury, eval lub pliku potraktowanego instrukcjami do/require/use. Je¶li wymieniono wiêcej ni¿ jedn± warto¶æ, lista musi byæ ujêta w nawiasy. Zobacz jeszcze sekcjê Private Variables via my() w podrêczniku perlsub(1).

next ETYKIETA

next

Komenda next jest podobna do instrukcji continue w C; rozpoczyna kolejn± iteracjê pêtli:

    LINE: while (<STDIN>) {

        next LINE if /^#/;      # pozb±d¼ siê komentarzy

        ...

    }

Zauwa¿, ¿e je¶li powy¿ej by³ blok continue, to zosta³by on wykonany nawet na usuniêtych liniach. Je¶li argument ETYKIETY jest pominiêty, komenda odnosi siê do najbardziej wewnêtrznej otaczaj±cej pêtli.

no Module LISTA

Zobacz funkcjê ``use'', gdzie ``no'' jest przeciwieñstwem.

oct WYRA¯

oct

Interpretuje WYRA¯ jako ³añcuch ósemkowy i zwraca odpowiadaj±c± warto¶æ. (Je¶li WYRA¯ zaczyna siê od 0x, jest interpretowane jako ³añcuch szesnastkowy.) Nastêpuj±cy kod obs³uguje liczby dziesiêtne, ósemkowe i szesnastkowe w standardowej notacji perla lub C:

    $val = oct($val) if $val =~ /^0/;

Je¶li WYRA¯ jest pominiête, u¿ywa $_. Funkcja ta jest czêsto u¿ywana gdy ³añcuch w rodzaju ``644'' musi byæ np. przekonwertowany na prawa pliku. (Chocia¿ perl automatycznie konwertuje ³añcuchy na liczby, zgodnie z potrzebami, to automatyczna konwersja zak³ada podstawê 10.)

open UCHWYTPLIKU,WYRA¯

open UCHWYTPLIKU

Otwiera plik, którego nazwa jest przekazywana WYRA¯, a nastêpnie wi±¿e go z UCHWYTEMPLIKU. Je¶li UCHWYTPLIKU jest wyra¿eniem, to jego warto¶æ jest u¿ywana jako nazwa rzeczywistego uchwytu pliku. Je¶li WYRA¯ jest pominiête, to przyjmuje siê, ¿e zmienna skalarna o tej samej nazwie co UCHWYTPLIKU zawiera nazwê pliku. (Zauwa¿, ¿e zmienne leksykalne---te, deklarowane z pomoc± my--nie bêd± w ten sposób dzia³a³y.)

Je¶li nazwa pliku rozpoczyna siê od `<' lub od niczego, plik jest otwierany dla wej¶cia (odczytu). Je¶li nazwa pliku rozpoczyna siê `>', plik jest kasowany i otwierany dla zapisu. Je¶li nazwa pliku rozpoczyna siê od `>>', plik jest otwierany dla dopisywania. Je¶li przed `>' lub `<' postawisz `+', oznacza to, ¿e chcesz zarówno czytaæ, jak i zapisywaæ do pliku. Tryb `+<' jest zazwyczaj preferowany dla poprawek odczytu/zapisu---tryb `+>' najpierw pobi³by plik. Przedrostek i nazwa pliku mog± byæ oddzielone spacjami. Wszystkie te przedrostki odpowiadaj± trybom otwarcia funkcji fopen(3).

Je¶li nazwa pliku rozpoczyna siê od ``|'', to plik jest rozumiany jako komenda, do której potokiem przesy³ane jest wyj¶cie. Odwrotnie, je¶li nazwa pliku koñczy siê tym symbolem, to nazwa pliku jest interpretowana jako komenda, której wyj¶cie jest przesy³ane potokiem na nasze wej¶cie (Zobacz sekcjê Using open() for IPC w podrêczniku perlipc(1)). (Mo¿esz nie mieæ czystego open(), powoduj±cego, ¿e komenda jest zarówno potokiem wej¶ciowym, jak i wyj¶ciowym. S± jednak na to rady, zobacz stronê podrêcznika IPC::Open2, IPC::Open3, oraz sekcjê Bidirectional Communication w podrêczniku perlipc(1).)

Otwieranie `-' otwiera strumieñ STDIN, a otwieranie `>-' otwiera STDOUT. Open po sukcesie zwraca zero, a w przeciwnym wypadku warto¶æ niezdefiniowan±. Je¶li open otworzy³ potok, warto¶æ zwracana jest identyfikatorem podprocesu (pid).

Je¶li masz na tyle pecha, ¿e pracujesz z perlem na systemie, który odró¿nia pliki tekstowe i binarne (nowoczesne systemy ich nie rozró¿niaj±), to powiniene¶ poczytaæ o funkcji binmode, opisanej gdzie¶ w tym dokumencie. Systemy, wymagaj±ce binmode rozpoznaje siê po ich formacie pliku tekstowego. Systemy takie, jak Unix i Plan9, które oddzielaj± linie pojedynczym znakiem i które koduj± go w C jako "\n", nie potrzebuj± binmode. Reszta tak.

Przyk³ady:

    $ARTICLE = 100;

    open ARTICLE or die "Nie mogê znale¼æ artyku³u $ARTICLE: $!\n";

    while (<ARTICLE>) {...

    open(LOG, '>>/usr/spool/news/twitlog'); # (log jest zarezerwowany)

    open(DBASE, '+<dbase.mine');            # otwórz dla odnowienia

    open(ARTICLE, "caesar <$article |");    # dekoduj artyku³

    open(EXTRACT, "|sort >/tmp/Tmp$$");     # $$ jest pidem naszego procesu

    # przetwórz listê argumentów plików, wraz z wszelkimi za³±cznikami

    foreach $file (@ARGV) {

        process($file, 'fh00');

    }

    sub process {

        local($filename, $input) = @_;

        $input++;               # jest to inkrementacja ³añcuchowa

        unless (open($input, $filename)) {

            print STDERR "Nie mogê otworzyæ $filename: $!\n";

            return;

        }

        while (<$input>) {              # note use of indirection

            if (/^#include "(.*)"/) {

                process($1, $input);

                next;

            }

            ...         # cokolwiek

        }

    }

Mo¿esz równie¿, zgodnie z tradycj± pow³oki Bourne, podaæ WYRA¯, zaczynaj±cy siê od ``>&'', co oznacza, ¿e reszta ³añcucha jest interpretowana jako nazwa uchwytu pliku (lub numerycznego deskryptora pliku), który nale¿y zduplikowaæ i otworzyæ. & mo¿na u¿yæ po >, >>, <, +>, +>>, i +<. Tryb, który podasz, powinien odpowiadaæ trybowi oryginalnego uchwytu pliku. (Duplikowanie uchwytów pliku nie pobiera na konto ¿adnych istniej±cych zawarto¶ci buforów stdio.) Oto skrypt, który zachowuje, przekierowuje i od¶wie¿a STDOUT i STDERR:

    #!/usr/bin/perl

    open(SAVEOUT, ">&STDOUT");

    open(SAVEERR, ">&STDERR");

    open(STDOUT, ">foo.out") || die "Nie mogê przekierowaæ stdout";

    open(STDERR, ">&STDOUT") || die "Nie mogê zduplikowaæ stdout";

    select(STDERR); $| = 1;     # zrób niebuforowane

    select(STDOUT); $| = 1;     # j/w

    print STDOUT "stdout 1\n";  # dzia³a to te¿ dla

    print STDERR "stderr 1\n";  # podprocesów

    close(STDOUT);

    close(STDERR);

    open(STDOUT, ">&SAVEOUT");

    open(STDERR, ">&SAVEERR");

    print STDOUT "stdout 2\n";

    print STDERR "stderr 2\n";

Mo¿esz podaæ ``<&=N'', gdzie N jest liczb±. Perl wtedy dokona operacji równowa¿nej fdopen(3) z C. Na przyk³ad:

    open(FILEHANDLE, "<&=$fd")

Je¶li otwierasz potok do komendy ``-'', np. albo ``|-'' albo ``-|'', to dokonywany jest niejawny fork, a zwrócona warto¶æ open jest wewn±trz procesu rodzicielskiego pidem potomka, a w w±tku potomka zerem. (Aby okre¶liæ, czy open by³ pomy¶lny, u¿yj defined($pid).) Uchwyt pliku u rodzica zachowuje siê normalnie, lecz i/o dla tego uchwytu jest przesy³ane przez potok STDOUT/STDIN procesu potomnego. W procesie potomny uchwyt nie jest otwierany---i/o jest z/do nowego STDOUT lub STDIN. Zazwyczaj jest to u¿ywane jak normalny potokowy open, lecz daje lepsz± kontrolê nad wywo³ywaniem komendy potoku, np. gdy pracujesz w suid i nie chcesz byæ zmuszonym do skanowania komend pow³oki w poszukiwaniu metaznaków. Nastêpuj±ce pary s± mniej lub bardziej równowa¿ne:

    open(FOO, "|tr '[a-z]' '[A-Z]'");

    open(FOO, "|-") || exec 'tr', '[a-z]', '[A-Z]';

    open(FOO, "cat -n '$file'|");

    open(FOO, "-|") || exec 'cat', '-n', $file;

Dla szczegó³ów, zobacz sekcjê Safe Pipe Opens w podrêczniku perlipc(1).

UWAGA: Przy ka¿dej operacji, dokonuj±cej forkowania, nieopró¿nione bufory pozostaj± takie w obydwu procesach, co znaczy, ¿e lepiej ustawiæ $|, aby zapobiec duplikowaniu wyj¶cia.

Zamykanie potokowego uchwytu pliku powoduje, ¿e proces rodzicielski czeka, a¿ dziecko zakoñczy i zwraca warto¶æ statusu w $?.

Je¶li u¿ywasz konstruktora z pakietu IO::Handle (lub z jego podklas, takich jak IO::File czy IO::Socket), mo¿esz generowaæ anonimowe uchwyty plików, które maj± zakres dowolnych zmiennych, które utrzymuj± do nich referencje. Zamykaj± siê one automatycznie po wyj¶ciu z zakresu:

    use IO::File;

    ...

    sub read_myfile_munged {

        my $ALL = shift;

        my $handle = new IO::File;

        open($handle, "myfile") or die "myfile: $!";

        $first = <$handle>

            or return ();     # Automatyczne zamkniêcie tutaj.

        mung $first or die "mung failed";       # Lub tutaj.

        return $first, <$handle> if $ALL;       # Lub tutaj.

        $first;                                 # Lub tutaj.

    }

Nazwa pliku, która jest przekazana open, przechodzi operacjê usuwania prowadz±cych i koñcz±cych bia³ych spacji. Aby otworzyæ plik, posiadaj±cy te dziwne znaki, trzeba je chroniæ:

    $file =~ s#^(\s)#./$1#;

    open(FOO, "< $file\0");

Je¶li chcesz u¿yæ prawdziwego, znanego z C open() (zobacz stronê open(2)), to powiniene¶ u¿yæ funkcji sysopen(). Jest to inny sposób chronienia nazw plików przed interpretacj±. Np:

    use IO::Handle;

    sysopen(HANDLE, $path, O_RDWR|O_CREAT|O_EXCL, 0700)

        or die "sysopen $path: $!";

    HANDLE->autoflush(1);

    HANDLE->print("stuff $$\n");

    seek(HANDLE, 0, 0);

    print "Plik zawiera: ", <HANDLE>;

Dla dalszych detali o miksowaniu odczytywania i zapisywania, obejrzyj opis seek(), znajduj±cy siê gdzie indziej w tym dokumencie.

opendir UCHWYTKATALOGU,WYRA¯

Otwiera katalog o nazwie WYRA¯. Otwarty uchwyt mo¿na przetwarzaæ funkcjami readdir(), telldir(), seekdir(), rewinddir(), i closedir(). Po sukcesie zwraca TRUE. Uchwyty katalogów maj± swoj± w³asn± przestrzeñ nazw. Jest ona oddzielna od uchwytów plików.

ord WYRA¯

ord

Zwraca numeryczn± warto¶æ ascii pierwszego znaku WYRA¯. Je¶li WYRA¯ zosta³o pominiête, u¿ywane jest $_. Dla operacji odwrotnej, zobacz opis chr, znajduj±cy siê gdzie¶ w tym dokumencie.

pack WZORZEC,LISTA

Pobiera tablicê lub listê warto¶ci i pakuje j± w strukturê binarn±, zwracaj±c ³añcuch, zawieraj±cy tê strukturê. WZORZEC jest sekwencj± znaków, które pokazuj± kolejno¶æ i typy warto¶ci. S± one nastêpuj±ce:

    A   £añcuch ascii, dope³niany spacjami.

    a   £añcuch ascii, dope³niany przez null.

    b   £añcuch bitowy (wznosz±ca kolejno¶æ bitów, jak w vec()).

    B   £añcuch bitowy (malej±ca kolejno¶æ bitów).

    h   £añcuch szesnastkowy (najpierw niski nibble).

    H   £añcuch szesnastkowy (najpierw wysoki nibble).

    c   Warto¶æ char ze znakiem.

    C   Warto¶æ char bez znaku.

    s   Warto¶æ short.

    S   Warto¶æ short bez znaku.

          (Ten 'short' jest _dok³adnie_ 16 bitowy, co mo¿e siê ró¿niæ od

             tego, co lokalny kompilator C nazywa jako 'short'.)

    i   Warto¶æ int ze znakiem.

    I   Warto¶æ int bez znaku.

          (Ten 'int' jest przynajmniej 32 bitowy. Dok³adny rozmiar zale¿y

           od tego, co lokalny kompilator C uwa¿a za 'int' i mo¿e byæ nawet

           wiêksze ni¿ 'long', opisywany dalej.)

    l   Warto¶æ long ze znakiem.

    L   Warto¶æ long bez znaku.

          (Ta warto¶æ 'long' jest _dok³adnie_ 32 bitowa, co mo¿e siê

           ró¿niæ od tego, co lokalny kompilator C uwa¿a za 'long'.)

    n   Short w porz±dku sieciowym (big-endian).

    N   Long w porz±dku sieciowym (big-endian).

    v   Short w porz±dku "VAX" (little-endian).

    V   Long w porz±dku "VAX" (little-endian).

          (Te 'short' i 'long' s± _dok³adnie_ 16 i

           32 bitowe (odpowiednio).)

    f   Float pojedynczej precyzji w formacie macierzystym.

    d   Float podwójnej precyzji w formacie macierzystym.

    p   Wska¼nik do ³añcucha zakoñczonego zerem.

    P   Wska¼nik do struktury (³añcuch o ustalonej d³ugo¶ci).

    u   Uuencodowany ³añcuch.

    w   Skompresowany integer BER. Jego bajty reprezentuj± ca³kowity

        integer o podstawie 128, najpierw bardziej znacz±ce cyfry,

        z tak ma³± ilo¶ci± cyfr, jak tylko siê da. Ósmy bit jest ustawiany

        na ka¿dym bajcie, poza ostatnim.

    x   Bajt null.

    X   Wstecz o bajt (?) (Back up a byte).

    @   Wype³nienie null do bezwzglêdnej pozycji (?)

        (Null fill to absolute position).

Po ka¿dej literze mo¿e opcjonalnie nastêpowaæ liczba, która podaje licznik powtórzeñ. Dla wszystkich typów, poza ``a'', ``A'', ``b'', ``B'', ``h'', ``H'', i ``P'', funkcja pack po¿re tyle samo warto¶ci z LISTY. Gwiazdka (*) dla licznika powtórzeñ, oznacza u¿ycie wszystkich elementów, które pozosta³y. Typy ``a'' i ``A'' pobieraj± tylko jedn± warto¶æ, lecz pakuj± j± jako ³añcuch o podanej d³ugo¶ci, wype³niaj±c j± w razie potrzeby zerami, lub spacjami. (Podczas rozpakowywania, ``A'' zdejmuje koñcz±ce spacje i zera, lecz ``a'' tego nie robi.) Podobnie, pola ``b'' i ``B'' pakuj± ³añcuchy, które s± d³ugo¶ci tylu bitów. ``h'' i ``H'' pakuj± ³añcuchy, które s± d³ugo¶ci tylu nibblów. ``P'' pakuje wska¼nik do struktury, której rozmiar jest wskazywany przez d³ugo¶æ. Liczby rzeczywiste (float, double) s± tylko w formacie macierzystym maszyny; z powodu wielo¶ci formatów zmiennoprzecinkowych i braku standardowej reprezentacji "sieciowej'', nie ma ¿adnego sposobu uniwersalnej wymiany. Oznacza to, ¿e spakowane dane zmiennoprzecinkowe, zapisane na jednej maszynie, mog± nie byæ odczytywalne na innej - nawet je¶li obydwie u¿ywaj± arytmetyki zmiennoprzecinkowej IEEE (gdy¿ endainowo¶æ pamiêci nie jest czê¶ci± specyfikacji IEEE). Zauwa¿, ¿e perl u¿ywa wewnêtrznie dla wszystkich obliczeñ numerycznych reprezentacji double i ¿e konwersja z double na float, a potem z powrotem na double powoduje utratê precyzji (np. unpack("f", pack("f", $foo)) nie bêdzie w ogólnym przypadku siê równaæ $foo).

Przyk³ady:

    $foo = pack("cccc",65,66,67,68);

    # foo to "ABCD"

    $foo = pack("c4",65,66,67,68);

    # to samo

    $foo = pack("ccxxcc",65,66,67,68);

    # foo to "AB\0\0CD"

    $foo = pack("s2",1,2);

    # "\1\0\2\0" na little-endian

    # "\0\1\0\2" na big-endian

    $foo = pack("a4","abcd","x","y","z");

    # "abcd"

    $foo = pack("aaaa","abcd","x","y","z");

    # "axyz"

    $foo = pack("a14","abcdefg");

    # "abcdefg\0\0\0\0\0\0\0"

    $foo = pack("i9pl", gmtime);

    # rzeczywista struktura tm (przynajmniej na moim systemie)

    sub bintodec {

        unpack("N", pack("B32", substr("0" x 32 . shift, -32)));

    }

Ten sam wzorzec mo¿e byæ ogólnie u¿ywany te¿ w funkcji unpack.

package PRZESTRZEÑNAZW

Deklaruje jednostkê kompilacji, przynale¿±c± do danej przestrzeni nazw. Zakres deklaracji pakietu le¿y od deklaracji, do koñca otaczaj±cego bloku (tak samo, jak zakres operatora local()). Wszelkie dalsze niekwalifikowane identyfikatory dynamiczne bêd± wewn±trz tej przestrzeni nazw. Instrukcja package dotyczy tylko zmiennych dynamicznych---w³±czaj±c w to te, których u¿y³e¶ lokalnie (local()),---lecz nie zmienne leksykalne, utworzone przez my(). Zazwyczaj jest to pierwsza deklaracja we w³±czanym przez require lub use pliku. Mo¿esz prze³±czyæ siê do pakietu w wiêcej ni¿ jednym miejscu; ma to wp³yw jedynie na to, której tablicy symboli u¿ywa kompilator dla reszty bloku. Do zmiennych i uchwytów plików z innych pakietów, mo¿esz odnosiæ siê, poprzedzaj±c identyfikatory nazwami pakietów, za którymi nastêpuj± dwa dwukropki: $Pakiet::Zmienna. Je¶li nazwa pakietu jest zerowa, u¿ywany jest pakiet main. Tak wiêc $::sail jest równowa¿ne $main::sail.

Zobacz sekcjê Packages w podrêczniku perlmod(1). Zobacz te¿ podrêcznik perlsub(1), gdzie opisane s± problemy zakresów.

pipe UCHWYTODCZYTU,UCHWYTZAPISU

Otwiera parê po³±czonych potoków, zupe³nie jak wywo³anie systemowe pipe(2). Zauwa¿, ¿e je¶li zestawiasz pêtle potokowych procesów, to o ile nie zachowasz ostro¿no¶ci, mo¿e pojawiæ siê deadlock. Dodatkowo, zauwa¿, ¿e potoki perla u¿ywaj± buforowania stdio, wiêc mo¿esz byæ zmuszonym ustawiæ $|, aby opró¿niæ swój UCHWYTZAPISU po ka¿dej z komend, zale¿nie od aplikacji.

Obejrzyj jeszcze stronê IPC::Open2, IPC::Open3 oraz sekcjê Bidirectional Communication z podrêcznika perlipc(1). S± tam przyk³ady takich rzeczy.

pop TABLICA

pop

Pobiera i zwraca ostatni± warto¶æ tablicy, skracaj±c j± o jeden. Ma podobne dzia³anie do

    $tmp = $ARRAY[$#ARRAY--];

Je¶li tablica nie ma elementów, zwracana jest warto¶æ niezdefiniowana. Je¶li parametr TABLICA zostanie pominiêty, to pobiera z tablicy @ARGV w programie g³ównym, oraz z @_ w podprocedurach, podobnie jak shift().

pos SKALAR

pos

Zwraca offset, gdzie dla zmiennej SKALAR zakoñczy³o siê ostatnie przeszukiwanie m//g. (Je¶li nie podano zmiennej, u¿ywany jest $_). Mo¿na go modyfikowaæ w celu zmieniania offsetu. Modyfikacja ta wp³ynie równie¿ na zapewnienia zerowej szeroko¶ci \G w wyra¿eniach regularnych. Zobacz podrêczniki perlref(1) i perlop(1).

print UCHWYTPLIKU LISTA

print LISTA

print

Drukuje oddzielon± przecinkami listê ³añcuchów. Po sukcesie zwraca TRUE. UCHWYTPLIKU mo¿e byæ nazw± zmiennej skalarnej, w którym wypadku zmienna ta przechowuje nazwê lub referencjê do uchwytu pliku, wprowadzaj±c tak poziom niebezpo¶rednio¶ci. (UWAGA: Je¶li UCHYTPLIKU jest zmienn±, a nastêpny token jest [term], to mo¿e to byæ ¼le zinterpretowane jako operator, chyba ¿e wstawisz +, lub ujmiesz argumenty w nawiasy.) Je¶li UCHWYTPLIKU jest pominiêty, drukowanie nastêpuje na standardowe wyj¶cie (lub do ostatnio wybranego kana³u wyj¶ciowego---zobacz opis select, znajduj±cy siê gdzie¶ w tym dokumencie ). Je¶li pominiêto równie¿ argument LISTY, na STDOUT drukowane jest $_. Aby ustawiæ kana³ wyj¶ciowy na co¶ innego ni¿ STDOUT, u¿yj operacji select. Zauwa¿, ¿e z uwagi na to, ¿e print pobiera LISTÊ, wszystko z LISTY jest analizowane w kontek¶cie listowym, a wszelka podprocedura, któr± wywo³asz, bêdzie mia³a jedno, lub wiêcej wyra¿eñ analizowanych w kontek¶cie listowym. Uwa¿aj te¿, by nie wpisywaæ z s³owem kluczowym print lewego nawiasu, chyba ¿e chcesz by odpowiadaj±cy prawy nawias koñczy³ argumenty do drukowania---wstaw +, lub otocz wszystkie argumenty nawiasami.

Zauwa¿, ¿e je¶li przechowujesz UCHWYTYPLIKÓW w tablicy, lub innym wyra¿eniu, bêdziesz musia³ u¿ywaæ bloku, zwracaj±cego jego warto¶æ:

    print { $files[$i] } "stuff\n";

    print { $OK ? STDOUT : STDERR } "stuff\n";

printf UCHWYTPLIKU FORMAT, LISTA

printf FORMAT, LISTA

Równowa¿ne print UCHWYTPLIKU sprintf(FORMAT, LISTA). Pierwszy argument list bêdzie interpretowany jako format printf. Je¶li w³±czone jest use locale, to znak u¿ywany dla kropki dziesiêtnej jest zale¿ny od locala LC_NUMERIC. Zobacz stronê podrêcznika perllocale(1).

Nie wpadnij w pu³apkê u¿ywania printf(), gdy wystarczy³by zwyk³y print(). Funkcja print() jest efektywniejsza i mniej wra¿liwa na b³êdy.

prototype FUNKCJA

Zwraca w postaci ³añcucha prototyp funkcji (lub undef, je¶li funkcja nie ma prototypu). FUNKCJA jest referencj± lub nazw± funkcji, której prototyp usi³ujemy uzyskaæ.

push TABLICA,LISTA

Traktuje TABLICÊ jako stos i wrzuca na jej szczyt warto¶ci LISTY. D³ugo¶æ TABLICY zwiêksza siê o d³ugo¶æ LISTY. Ma takie samo dzia³anie jak

    for $value (LIST) {

        $ARRAY[++$#ARRAY] = $value;

    }

lecz jest efektywniejsze. Zwraca now± liczbê elementów tablicy.

q/£AÑCUCH/

qq/£AÑCUCH/

qx/£AÑCUCH/

qw/£AÑCUCH/

Uogólnione cudzys³owy. Zobacz stronê perlop(1).

quotemeta WYRA¯

quotemeta

Zwraca warto¶æ WYRA¯ z poprzedzonymi odwróconymi uko¶nikami wszystkimi nie-alfanumerycznymi znakami. (To znaczy, ¿e wszystkie znaki, nie podpadaj±ce pod /[A-Za-z_0-9]/ zostan± poprzedzone odwrotnym uko¶nikiem, niezale¿nie od ustawieñ locale.) Jest to wewnêtrzna funkcja, implementuj±ca escape Q w ³añcuchach z podwójnych cudzys³owów.

Je¶li WYRA¯ jest pominiête, u¿ywane jest $_.

rand WYRA¯

rand

Zwraca losow± liczbê, wiêksz± lub równ± 0 i mniejsz± od warto¶ci WYRA¯. (WYRA¯ powinno byæ dodatnie.) Je¶li WYRA¯ jest pominiête, u¿ywana jest warto¶æ 1. Automatycznie wywo³uje srand(), chyba ¿e by³ on ju¿ wywo³any. Zobacz te¿ opis srand().

(Uwaga: Je¶li twoja funkcja rand zwraca stale liczby, które s± zbyt wielkie, lub zbyt ma³e, to znaczy, ¿e twoja wersja perla prawdopodobnie zosta³a skompilowana ze z³± liczb± RANDBITS.)

read UCHWYTPLIKU,SKALAR,D£UGO¦Æ,OFFSET

read UCHWYTPLIKU,SKALAR,D£UGO¦Æ

Próbuje odczytaæ D£UGO¦Æ bajtów danych do zmiennej SKALAR z pliku wskazywanego przez UCHWYTPLIKU. Zwraca liczbê odczytanych bajtów, lub undef w wypadku b³êdu. SKALAR zostanie rozci±gniêty, lub skurczony do rzeczywistej d³ugo¶ci odczytanych danych. Mo¿na te¿ podaæ OFFSET. Wtedy odczyt nast±pi w innym miejscu ni¿ pocz±tek ³añcucha. Wywo³anie to jest w rzeczywisto¶ci zaimplementowane w oparciu o wywo³anie fread(3) stdio. Aby uzyskaæ prawdziwe wywo³anie systemowe read(2), u¿yj sysread().

readdir UCHWYTKATALOGU

Zwraca nastêpny wpis katalogu, otwartego przez opendir(). Je¶li jest u¿ywane w kontek¶cie listowym, zwraca resztê wpisów w katalogu. Je¶li nie ma ju¿ wiêcej wpisów, w kontek¶cie skalarnym zwracana jest warto¶æ niezdefiniowana, a w kontek¶cie listowym listê null.

Je¶li masz zamiar dokonywaæ testów plikowych na warto¶ciach zwracanych przez readdir(), to lepiej poprzed¼ te nazwy katalogiem. Powinno siê tak robiæ, gdy¿ nie readdir() nie przechodzi do swojego katalogu i zasz³o by testowanie nie tego pliku co trzeba.

    opendir(DIR, $some_dir) || die "Nie powiód³ siê opendir $some_dir: $!";

    @dots = grep { /^\./ && -f "$some_dir/$_" } readdir(DIR);

    closedir DIR;

readlink WYRA¯

readlink

Zwraca warto¶æ dowi±zania symbolicznego. Dzia³a to, je¶li dowi±zania symboliczne s± zaimplementowane [w systemie]. W przeciwnym wypadku powstaje b³±d krytycznych. W wypadku b³êdu systemowego, zwracana jest warto¶æ niezdefiniowana i ustawiane jest $! (errno). Je¶li WYRA¯ zostanie pominiête, u¿ywane jest $_.

recv GNIAZDO,SKALAR,D£UGO¦Æ,FLAGI

Odbiera komunikat na gnie¼dzie. Próbuje odebraæ D£UGO¦Æ bajtów do zmiennej SKALAR. (GNIAZDO to uchwyt gniazda). W rzeczywisto¶ci funkcja wykonuje odpowiednik funkcji C recvfrom()(2), wiêc zwraca adres nadawcy. W wypadku b³êdu, zwracana jest warto¶æ niezdefiniowana. SKALAR bêdzie rozci±gany do d³ugo¶ci rzeczywi¶cie odczytanych danych. Flagi s± takie same jak w wywo³aniu systemowym o tej samej nazwie. Zobacz jeszcze sekcjê UDP: Message Passing w podrêczniku perlipc(1). S± tam przyk³ady.

redo ETYKIETA

redo

Komenda redo restartuje blok pêtli, nie analizuj±c przy tym warunku. Blok continue (je¶li taki istnieje) równie¿ nie jest wykonywany. Je¶li pominiêta zostanie ETYKIETA, komenda odnosi siê do najbardziej wewnêtrznej otaczaj±cej pêtli. Komenda ta jest zazwyczaj wykorzystywana przez programy, które chc± siê oszukiwaæ co do tego, co by³o w³a¶nie pobrane:

    # Uproszczony ogo³acacz komentarzy Pascala

    # (uwaga: zak³ada brak { i } w ³añcuchach)

    LINE: while (<STDIN>) {

        while (s|({.*}.*){.*}|$1 |) {}

        s|{.*}| |;

        if (s|{.*| |) {

            $front = $_;

            while (<STDIN>) {

                if (/}/) {      # Koniec komentarza?

                    s|^|$front{|;

                    redo LINE;

                }

            }

        }

        print;

    }

ref WYRA¯

ref

Je¶li warto¶æ WYRA¯ jest referencj±, zwracane jest TRUE, a w przeciwnym wypadku FALSE. Je¶li WYRA¯ zostanie pominiête, u¿yte zostanie $_. Zwracana warto¶æ zale¿y od typu, do którego referencja jest referencj±. Wbudowane typy to:

    REF

    SCALAR

    ARRAY

    HASH

    CODE

    GLOB

Je¶li referencjowany obiekt zosta³ b³ogos³awiony (bless()) do pakietu, to zwracana jest nazwa pakietu. Mo¿esz my¶leæ o ref() jak o operatorze typeof().

    if (ref($r) eq "HASH") {

        print "r jest referencj± do tablicy asocjacyjnej.\n";

    }

    if (!ref ($r) {

        print "r nie jest referencj±.\n";

    }

Zobacz te¿ stronê podrêcznika perlref(1).

rename STARANAZWA,NOWANAZWA

Zmienia nazwê pliku. Po sukcesie zwraca 1, w przeciwnym wypadku 0. Nie dzia³a miêdzy granicami systemów plików.

require WYRA¯

require

Za¿±daj pewnej w³a¶ciwo¶ci, podanej przez WYRA¯, lub $_, je¶li go nie podano. Je¶li WYRA¯ jest numeryczne, to wymaga ono by bie¿±ca wersja perla ($] lub $PERL_VERSION) by³a wiêksza lub równa WYRA¯.

W przeciwnym wypadku ¿±da w³±czenia pliku biblioteki (o ile nie jest on ju¿ w³±czony). Plik jest w³±czany z u¿yciem mechanizmu do-PLIK, który w zasadzie jest wariacj± eval(). Semantyka jest podobna do nastêpuj±cej podprocedury:

    sub require {

        local($filename) = @_;

        return 1 if $INC{$filename};

        local($realfilename,$result);

        ITER: {

            foreach $prefix (@INC) {

                $realfilename = "$prefix/$filename";

                if (-f $realfilename) {

                    $result = do $realfilename;

                    last ITER;

                }

            }

            die "Nie mogê znale¼æ $filename w \@INC";

        }

        die $@ if $@;

        die "$filename nie zwróci³o prawdziwej warto¶ci" unless $result;

        $INC{$filename} = $realfilename;

        $result;

    }

Zauwa¿, ¿e plik nie bêdzie w³±czany pod t± sam± nazw± dwukrotnie. Jako ostatni± instrukcjê, plik musi zwracaæ TRUE, wskazuj±c tak pomy¶lne wykonanie kodu inicjalizacji, wiêc zazwyczaj koñczy siê takie pliki ``1;'', chyba ¿e jeste¶ pewien, ¿e zwróci TRUE tak czy inaczej. Lepiej jednak wstawiæ po prostu``1;'', na wypadek np. dodania nowych instrukcji.

Je¶li WYRA¯ jest prostym s³owem, require zak³ada rozszerzenie ``.pm'' i samodzielnie zamienia ``::'' na ``/'', u³atwiaj±c ³adowanie modu³ów standardowych. Ta postaæ ³adowania modu³ów nie ryzykuje zmieniania twojej przestrzeni nazw. to make it easy to load standard modules. This form of loading of modules does not risk altering your namespace.

Dla potê¿niejszego narzêdzia importu, obejrzyj opis use, znajduj±cy siê w tym dokumencie, oraz stronê perlmod(1).

reset WYRA¯

reset

Ogólnie, u¿ywane w bloku continue na koñcu pêtli, w celu wyczyszczenia zmiennych i resetowania przeszukiwañ ??, tak by znów dzia³a³y. Wyra¿enie jest interpretowane jako lista pojedynczych znaków (dla podawania zakresów, mo¿na u¿ywaæ my¶lników). Wszystkie zmienne i tablice, rozpoczynaj±ce siê na jedn± z tych liter, s± resetowane do stanu pierwotnego. Je¶li wyra¿enie zostanie pominiête, przeszukiwania jednego-trafienia (?wzorzec?) s± resetowane do ponownego trafienia. Resetowanie tyczy siê tylko obiektów bie¿±cego pakietu. Zwracane jest zawsze 1. Przyk³ady:

    reset 'X';          # resetuj wszystkie zmienne X

    reset 'a-z';        # resetuj zmienne ma³oliterowe

    reset;              # resetuj tylko przeszukiwania ??

Resetowanie ``A-Z'' nie jest zalecane, gdy¿ odniesie siê ono równie¿ do tablic ARGV i ENV. Resetowane s± tylko zmienne pakietu---zmienne leksykalne s± nietykane, lecz one i tak oczyszczaj± siê na wyj¶ciu z zakresu. Zobacz opis my, znajduj±cy siê gdzie¶ w tym dokumencie.

return WYRA¯

return

Powraca z podprocedury, eval(), lub z do PLIK, z warto¶ci± podan± przez WYRA¯. Analiza WYRA¯ mo¿e zachodziæ w kontek¶cie listowym, skalarnym, lub pustym (void). Zale¿y to od sposobu u¿ycia warto¶ci zwracanej, a kontekst mo¿e siê zmieniaæ od jednego wywo³ania do drugiego (zobacz wantarray()). Je¶li WYRA¯ nie jest podane, w kontek¶cie skalarnym zwracana jest warto¶æ niezdefiniowana, w listowym pusta lista, a w pustym (void) nic.

(Zauwa¿, ¿e przy braku return, podprocedura, eval, lub do PLIK zakoñcz± automatycznie z warto¶ci± ostatniego wykonanego wyra¿enia.)

reverse LISTA

W kontek¶cie listowym, zwraca warto¶æ listow±, sk³adaj±c± siê z elementów LISTY, u³o¿onych w przeciwnym porz±dku. W kontek¶cie skalarnym, elementy listy s± ³±czone w ³añcuch i zwracane w odwróconym porz±dku.

    print reverse <>;           # line tac, last line first

    undef $/;                   # for efficiency of <>

    print scalar reverse <>;    # byte tac, last line tsrif

Operator ten jest te¿ przydatny do inwersji tablicy asocjacyjnej, choæ s± tu pewne zastrze¿enia. Je¶li warto¶æ jest w oryginalnej tablicy zduplikowana, to tylko jedna z nich mo¿e byæ reprezentowana jako klucz w tablicy odwróconej. Musi to te¿ przewin±æ ca³± tablicê i zbudowaæ now±, co dla du¿ej tablicy mo¿e trochê potrwaæ.

    %by_name = reverse %by_address;     # Inwersja tablicy asocjacyjnej

rewinddir UCHWYTKATALOGU

Ustawia bie¿±c± pozycjê (dla funkcji readdir()) na pocz±tek katalogu, wskazywanego przez UCHWYTKATALOGU.

rindex STR,SUBSTR,POZYCJA

rindex STR,SUBSTR

Dzia³a tak samo jak index, lecz zwraca pozycjê ostatniego pojawienia siê SUBSTR w STR. Je¶li podano POZYCJÊ, to zwracane jest ostatnie pojawienie na, lub przed t± pozycj±.

rmdir NAZWAPLIKU

rmdir

Kasuje pusty katalog podany przez NAZWÊPLIKU. Je¶li operacja siê powiedzie, zwraca 1. W przeciwnym wypadku zwracane jest zero i ustawiane jest $! (errno). Je¶li NAZWAPLIKU jest pominiêta, u¿ywane jest $_.

s///

Operator podmienienia. Zobacz stronê perlop(1).

scalar WYRA¯

Wymusza interpretacjê skalarn± wyra¿enia WYRA¯ i zwraca jego warto¶æ.

    @counts = ( scalar @a, scalar @b, scalar @c );

Nie istnieje odpowiednik, konwertuj±cy skalar w listê. Jest tak dlatego, ¿e w praktyce nie jest on nigdy potrzebny. Je¶li jednak naprawdê chcesz tak zrobiæ, mo¿esz u¿yæ konstrukcji @{[ (jakie¶ wyra¿enie) ]}, a zwykle powinno wystarczyæ zwyk³e (some expression).

seek UCHWYTPLIKU,POZYCJA,GDZIE

Ustawia pozycjê UCHWYTUPLIKU, podobnie jak fseek(3) w stdio. UCHYTPLIKU mo¿e byæ wyra¿eniem, którego warto¶æ daje nazwê uchwytu pliku. Warto¶ci GDZIE to 0, oznaczaj±ce ustawianie nowej pozycji na POZYCJÊ, 1 oznaczaj±ce ustawianie pozycji na pozycjê bie¿±c± plus POZYCJÊ, oraz 2 ustawiaj±ce pozycjê na EOF plus POZYCJÊ (zazwyczaj ujemn±). Zamiast numerycznych warto¶ci GDZIE, mo¿na u¿ywaæ sta³ych SEEK_SET, SEEK_CUR i SEEK_END z modu³u IO::Seekable lub POSIX. Po sukcesie zwracane jest 1, po b³êdzie 0.

Je¶li chcesz ustawiæ pozycjê pliku dla sysread() i syswrite(), nie u¿ywaj seek() -- u¿yj sysseek().

Na niektórych systemach musisz wykonaæ seek za ka¿dym razem, gdy prze³±czasz siê miêdzy zapisem i odczytem. W¶ród innych rzeczy, mo¿e to mieæ efekt wo³ania funkcji stdio clearerr(3). Warto¶æ GDZIE 1 jest przydatna do nie ruszania siê z pozycji pliku:

    seek(TEST,0,1);

Jest to równie¿ przydatne dla aplikacji, emuluj±cych tail -f. Gdy raz wejdziesz na EOF, a potem za¶niesz na chwilê, to dobrze przed nastêpnym odczytem u¿yæ seek(), aby wszystko zresetowaæ. seek() nie zmienia bie¿±cej pozycji, lecz czy¶ci warunek EOF uchwytu, wiêc nastêpne <PLIK> powoduje, ¿e perl znów co¶ bêdzie próbowa³ odczytaæ. Mamy przynajmniej tak± nadziejê.

Je¶li to nie dzia³a (niektóre stdio s± szczególnie dziwne), to mo¿esz potrzebowaæ czego¶ wiêcej, jak:

    for (;;) {

        for ($curpos = tell(FILE); $_ = <FILE>; $curpos = tell(FILE)) {

            # szukaj jakich¶ rzeczy i wstaw je do plików

        }

        sleep($for_a_while);

        seek(FILE, $curpos, 0);

    }

seekdir UCHWYTKATALOGU,POZYCJA

Ustawia bie¿±c± pozycjê polecenia readdir() dla katalogu wskazywanego przez UCHWYTKATALOGU. POZYCJA musi mieæ warto¶æ zwracan± przez telldir().

select UCHWYTPLIKU

select

Zwraca obecnie wybrany uchwyt pliku. Je¶li podano UCHWYTPLIKU, ustawia domy¶lny uchwyt pliku dla wyj¶cia. Daje to dwa efekty: po pierwsze write, lub print bez uchwytu pliku bêd± zapisywa³y domy¶lnie do tego UCHWYTUPLIKU. Po drugie, odniesienia zmiennych, zwi±zanych z wyj¶ciem, bêd± siê odnosi³y do tego kana³u wyj¶cia. Np. je¶li masz ustawiæ pocz±tek formatu formy dla wiêcej ni¿ jednego kana³u, móg³by¶ u¿yæ nastêpuj±cego:

    select(REPORT1);

    $^ = 'report1_top';

    select(REPORT2);

    $^ = 'report2_top';

UCHWYTPLIKU mo¿e byæ wyra¿eniem, które daje nazwê rzeczywistego uchwytu pliku. Tak wiêc:

    $oldfh = select(STDERR); $| = 1; select($oldfh);

Niektórzy programi¶ci wol± my¶leæ o uchwytach pliku jak o obiektach, posiadaj±cych metody, zapisuj±c ostatni przyk³ad jako:

    use IO::Handle;

    STDERR->autoflush(1);

select RBITS,WBITS,EBITS,TIMEOUT

Funkcja ta wo³a z podanymi maskami bitowymi wywo³anie systemowe select(2). Maski mo¿na skonstruowaæ, u¿ywaj±c fileno() i vec():

    $rin = $win = $ein = '';

    vec($rin,fileno(STDIN),1) = 1;

    vec($win,fileno(STDOUT),1) = 1;

    $ein = $rin | $win;

Je¶li chcesz wykonywaæ tê funkcjê na wielu uchwytach plików, mo¿esz napisaæ podprocedurê:

    sub fhbits {

        local(@fhlist) = split(' ',$_[0]);

        local($bits);

        for (@fhlist) {

            vec($bits,fileno($_),1) = 1;

        }

        $bits;

    }

    $rin = fhbits('STDIN TTY SOCK');

Spotykanym idiomem jest:

    ($nfound,$timeleft) =

      select($rout=$rin, $wout=$win, $eout=$ein, $timeout);

aby blokowaæ, a¿ co¶ stanie siê gotowe, wykonaj po prostu

    $nfound = select($rout=$rin, $wout=$win, $eout=$ein, undef);

Wiêkszo¶æ systemów nie zwraca niczego m±drego w $timeleft, wiêc wywo³anie select() w kontek¶cie skalarnym zwróci po prostu $nfound.

Ka¿da z masek bitowych mo¿e byæ niezdefiniowana. Podany timeout jest podawany w sekundach. Mo¿e byæ u³amkowy. Uwaga: nie wszystkie implementacje zwracaj± $timeleft. Je¶li go nie zwracaj±, to zwracaj± warto¶æ równ± tej, przekazanej w $timeout.

A oto 250 milisekundowe za¶niêcie:

    select(undef, undef, undef, 0.25);

UWAGA: Nie próbuj ³±czyæ buforowanego I/O (np. read czy <FH>) z funkcj± select. U¿yj zamiast tego sysread().

semctl ID,SEMNUM,CMD,ARG

Wo³a funkcjê IPC semctl(2) z Systemu V. Je¶li CMD to &IPC_STAT lub &GETALL, to ARG musi byæ zmienn±, która bêdzie przechowywaæ zwrócon± strukturê semid_ds, lub tablicê warto¶ci semafora. Podczas b³êdu, podobnie jak ioctl zwraca warto¶æ niezdefiniowan±, dla zera ³añcuch ``0 but true'', a dla pozosta³ych warto¶ci rzeczywist± warto¶æ zwrócon±.

semget KLUCZ,NSEMS,FLAGI

Wo³a funkcjê IPC semget(2) z Systemu V. Zwraca identyfikator semafora, lub warto¶æ niezdefiniowan± w przypadku b³êdu.

semop KLUCZ,£AÑCUCHOP

Wo³a funkcjê IPC semop(2) z Systemu V. Funkcja ta dokonuje operacji semaforowych, np. sygnalizowania i czekania. £AÑCUCHOP musi byæ spakowan± tablic± struktur semop. Ka¿d± ze struktur semop mo¿na wygenerowaæ z pomoc± pack("sss", $semnum, $semop, $semflag). Liczba operacji semaforowych jest implikowana d³ugo¶ci± £AÑCUCHOP. Po sukcesie, funkcja zwraca TRUE, a w wypadku b³êdu FALSE. Na przyk³ad nastêpuj±cy fragment kodu oczekuje na semaforze $semnum z identyfikatora $semid:

    $semop = pack("sss", $semnum, -1, 0);

    die "Problem z semaforem: $!\n" unless semop($semid, $semop);

Aby ustawiæ semafor, zamieñ ``-1'' na ``1''.

send GNIAZDO,MSG,FLAGI,DO

send GNIAZDO,MSG,FLAGI

Wysy³a na gniazdo komunikat. Pobiera takie same flagi, jak wywo³anie systemowe send(2). Na gniazdach niepod³±czonych, nale¿y podaæ cel wysy³ania, czyli argument DO. W tej sytuacji u¿yta zostanie funkcja C sendto(2). Funkcja zwraca liczbê wys³anych znaków, lub w wypadku b³êdu warto¶æ niezdefiniowan±. Zobacz jeszcze sekcjê UDP: Message Passing w podrêczniku perlipc(1). S± tam przyk³ady.

setpgrp PID,PGRP

Ustawia bie¿±c± grupê procesów dla podanego PIDa (wynosz±cego 0 dla procesu bie¿±cego). Funkcja powoduje b³±d krytyczny na maszynach nie implementuj±cych setpgrp(2). Je¶li argumenty s± pominiête, odnosi siê to domy¶lnie do 0,0. Zauwa¿, ¿e wersja POSIX setpgrp() nie przyjmuje ¿adnych argumentów, wiêc przeno¶ne jest tylko setpgrp 0,0.

setpriority CZYJE,KTO,PRIORYTET

Ustawia bie¿±cy priorytet procesu, grupy procesów, lub u¿ytkownika. (Zobacz setpriority(2).) Na maszynach nie implementuj±cych tego wywo³ania systemowego, powoduje b³±d krytyczny.

setsockopt GNIAZDO,POZIOM,NAZWAOPC,WARTOPC

Ustawia ¿±dan± opcjê gniazda. W wypadku b³êdu, zwraca warto¶æ niezdefiniowan±. Je¶li nie chcesz przekazywaæ argumentu, WARTOPC mo¿e byæ podane jako undef.

shift TABLICA

shift

Wysuwa pierwsz± warto¶æ tablicy i zwraca j±, skracaj±c tablicê o 1 i przenosz±c wszystko w dó³. Je¶li w tablicy nie ma elementów, zwracana jest warto¶æ niezdefiniowana. Je¶li TABLICA zostanie pominiêta, to przesuwana jest w programie g³ównym tablica @ARGV, oraz @_ w podprocedurach. (Jest to okre¶lone leksykalnie.) Zobacz te¿ unshift(), push() oraz pop(). Shift() i unshift() robi± to samo na lewym koñcu tablicy, co pop() i push() na prawym.

shmctl ID,CMD,ARG

Wo³a funkcjê IPC shmctl(2) z Systemu V. Je¶li CMD jest &IPC_STAT, to ARG musi byæ zmienn±, która bêdzie przechowywaæ zwrócon± strukturê shmid_ds. Warto¶æ zwracana jest jak w ioctl: warto¶æ niezdefiniowana dla b³êdu, ``0 but true'' dla zera i rzeczywista warto¶æ zwrócona w innych wypadkach.

shmget KLUCZ,ROZMIAR,FLAGI

Wo³a funkcjê IPC shmget(2) z Systemu V. Zwraca identyfikator pamiêci dzielonej, a w przypadku b³êdu warto¶æ niezdefiniowan±.

shmread ID,ZMIENNA,POZYCJA,ROZMIAR

shmwrite ID,£AÑCUCH,POZYCJA,ROZMIAR

Odczytuje, lub zapisuje segment pamiêci dzielonej, rozpoczynaj±c w pozycji POZYCJA i obs³uguj±c rozmiar ROZMIAR bajtów. Podczas odczytu, ZMIENNA musi byæ elementem, który bêdzie przechowywa³ odczytane dane. Podczas zapisywania, je¶li £AÑCUCH jest zbyt d³ugi, u¿ytych zostanie tylko ROZMIAR bajtów; je¶li £AÑCUCH jest zbyt krótki, to reszta zostanie wype³niona nullami. Funkcja zwraca po sukcesie TRUE oraz FALSE w wypadku b³êdu.

shutdown GNIAZDO,JAK

Wy³±cza po³±czenie na gnie¼dzie, w sposób wskazany przez JAK, który ma tak± sam± interpretacjê, jak w wywo³aniu systemowym shutdown(2).

sin WYRA¯

sin

Zwraca sinus z WYRA¯ (podanego w radianach). Je¶li WYRA¯ jest pominiête, zwracana jest warto¶æ dla $_.

Dla operacji odwrotnej do sinusa, mo¿esz u¿yæ funkcji POSIX::asin(), lub nastêpuj±cej relacji:

    sub asin { atan2($_[0], sqrt(1 - $_[0] * $_[0])) }

sleep WYRA¯

sleep

Powoduje, ¿e skrypt zasypia na WYRA¯ sekund, lub na zawsze, je¶li nie podano WYRA¯. Spanie mo¿na przerwaæ, przesy³aj±c procesowi SIGALRM. Zwraca ilo¶æ przespanych sekund. Przypuszczalnie nie powinno siê ³±czyæ wywo³añ alarm() i sleep(), gdy¿ sleep() jest czêsto implementowane przy u¿yciu alarm().

Na niektórych systemach, spanie mo¿e trwaæ do sekundy mniej ni¿ ¿±da³e¶, zale¿nie od sposobu obliczania sekund. Wiêkszo¶æ nowoczesnych systemów przesypia ca³y okres.

Dla pauz, lub wiêkszej dok³adno¶ci ni¿ sekunda, mo¿esz u¿yæ interfejsu syscall() perla i dostaæ siê do funkcji setitimer(2), o ile jest ona obs³ugiwana przez twój system. Mo¿esz te¿ zapoznaæ siê z opisem select(), znajduj±cym siê gdzie¶ w tym dokumencie.

Zobacz tak¿e funkcjê sigpause() z modu³u POSIX.

socket GNIAZDO,DOMENA,TYP,PROTOKÓ£

Otwiera gniazdo podanego typu i przywi±zuje je do uchwytu pliku GNIAZDO. DOMENA, TYP i PROTOKÓ£ s± takie same jak dla wywo³ania systemowego socket(2). Przed u¿ywaniem tej funkcji, powiniene¶ u¿yæ ``use Socket;'', aby zaimportowaæ odpowiednie definicje. Obejrzyj przyk³ad w sekcji Sockets: Client/Server Communication w podrêczniku perlipc(1).

socketpair GNIAZDO1,GNIAZDO2,DOMENA,TYP,PROTOKÓ£

Tworzy nienazwan± parê gniazd danego typu, w podanej domenie. DOMENA, TYP i PROTOKÓ£ s± podawane tak samo, jak dla wywo³ania systemowego socketpair(2). Je¶li funkcja nie jest zaimplementowana, to powoduje b³±d krytyczny. Po sukcesie zwracane jest TRUE.

sort NAZWA LISTA

sort BLOK LISTa

sort LISTA

Sortuje LISTÊ i zwraca posortowan± warto¶æ listow±. Je¶li pominiête zostan± parametry NAZWA lub BLOK, sortowanie nastêpuje w porz±dku porównywania ³añcuchów. Je¶li podano NAZWÊ, to wskazuje ona na podprocedurê, zwracaj±c± liczbê ca³kowit±, która jest mniejsza, równa, lub wiêksza od zera, zale¿nie od tego, jak elementy tablicy maj± byæ pouk³adane. W takich procedurach bardzo przydatne s± operatory <=> oraz cmp. NAZWA mo¿e byæ nazw± zmiennej skalarnej--w tym wypadku warto¶æ daje nazwê u¿ywanej podprocedury. Zamiast NAZWY mo¿na podaæ BLOK, czyli anonimow± podprocedurê sortuj±c±.

W celu polepszenia efektywno¶ci, pomijany jest normalny kod wo³ania podprocedur: podprocedura nie mo¿e byæ rekurencyjna, a dwa porównywane elementy nie s± przekazywane przez @_, lecz jako globalne zmienna pakietu $a oraz $b (zobacz przyk³ad poni¿ej). S± one przekazywane przez referencjê, wiêc nie modyfikuj ani $a, ani $b. Nie próbuj te¿ deklarowaæ ich jako leksykalne.

Nie mo¿na te¿ wyj¶æ z bloku sortuj±cego przy u¿yciu ¿adnego operatora kontroli pêtli czy goto().

Gdy dzia³a use locale, sort LIST sortuje LISTÊ wed³ug odpowiedniego locale. Zobacz stronê perllocale(1).

Przyk³ady:

    # sortuj leksykalnie

    @articles = sort @files;

    # to samo, z jawn± procedur± sortuj±c±

    @articles = sort {$a cmp $b} @files;

    # teraz niewra¿liwie na wielko¶æ liter

    @articles = sort {uc($a) cmp uc($b)} @files;

    # to samo w odwrotnym porz±dku

    @articles = sort {$b cmp $a} @files;

    # sortuj rosn±co, numerycznie

    @articles = sort {$a <=> $b} @files;

    # j/w, malej±co

    @articles = sort {$b <=> $a} @files;

    # sortuj, u¿ywaj±c jawnej nazwy podprocedury

    sub byage {

        $age{$a} <=> $age{$b};  # za³o¿enie numeryczno¶ci

    }

    @sortedclass = sort byage @class;

    # to sortuje tablicê asocjacyjn± %age wed³ug warto¶ci (zamiast klucza)

    # przy u¿yciu funkcji inline

    @eldest = sort { $age{$b} <=> $age{$a} } keys %age;

    sub backwards { $b cmp $a; }

    @harry = ('dog','cat','x','Cain','Abel');

    @george = ('gone','chased','yz','Punished','Axed');

    print sort @harry;

            # drukuje AbelCaincatdogx

    print sort backwards @harry;

            # drukuje xdogcatCainAbel

    print sort @george, 'to', @harry;

            # drukuje AbelAxedCainPunishedcatchaseddoggonetoxyz

    # sortuj nieefektywnie wed³ug malej±cego porównania numerycznego,

    # u¿ywaj±c pierwszej liczby ca³kowitej po znaku =, lub w przeciwnym

    # wypadku ca³y rekord, bez zwracania uwagi na wielko¶æ liter.

    @new = sort {

        ($b =~ /=(\d+)/)[0] <=> ($a =~ /=(\d+)/)[0]

                            ||

                    uc($a)  cmp  uc($b)

    } @old;

    # to samo, du¿o efektywniej;

    # zbudujemy zewnêtrzne indeksy

    @nums = @caps = ();

    for (@old) {

        push @nums, /=(\d+)/;

        push @caps, uc($_);

    }

    @new = @old[ sort {

                        $nums[$b] <=> $nums[$a]

                                 ||

                        $caps[$a] cmp $caps[$b]

                       } 0..$#old

               ];

    # to samo, przy u¿yciu Schwartzian Transform (bez tymczasowych)

    @new = map { $_->[0] }

        sort { $b->[1] <=> $a->[1]

                        ||

               $a->[2] cmp $b->[2]

        } map { [$_, /=(\d+)/, uc($_)] } @old;

Je¶li u¿ywasz strict, nie mo¿esz deklarowaæ $a i $b jako leksykalia. S± one pakietowymi globaliami. Znaczy to, ¿e je¶li jeste¶ w pakiecie g³ównym (main), to jest to

    @articles = sort {$main::b <=> $main::a} @files;

kub po prostu

    @articles = sort {$::b <=> $::a} @files;

lecz je¶li jeste¶ w pakiecie FooPack, to jest to

    @articles = sort {$FooPack::b <=> $FooPack::a} @files;

Funkcja porównuj±ca musi siê zachowywaæ [jednoznacznie]. Je¶li zwraca niespójne, nielogiczne wyniki (np. czasem mówi±c, ¿e $x[1] jest mniejsze ni¿ $x[2], a czasem odwrotnie), to interpreter perla prawdopodobnie siê wysypie i zrzuci core. Wynika to ca³kowicie z zale¿no¶ci od systemowej funkcji bibliotecznej qsort(3); funkcja ta czêsto nie dokonuje pewnych sprawdzeñ w celu polepszenia szybko¶ci.

splice TABLICA,OFFSET,D£UGO¦Æ,LISTA

splice TABLICA,OFFSET,D£UGO¦Æ

splice TABLICA,OFFSET

Usuwa z tablicy elementy wskazane przez OFFSET i D£UGO¦Æ, oraz zamienia je ewentualnie podanymi elementami LISTY. Zwraca elementy, które zosta³y z tablicy usuniête. Tablica zgodnie z potrzebami ro¶nie, lub maleje. Je¶li parametr D£UGO¦Æ zostanie pominiêty, to usuwane jest wszystko, poczynaj±c od OFFSET. A oto pewne równowa¿no¶ci (zak³adaj±c, ¿e $[ == 0):

    push(@a,$x,$y)      splice(@a,$#a+1,0,$x,$y)

    pop(@a)             splice(@a,-1)

    shift(@a)           splice(@a,0,1)

    unshift(@a,$x,$y)   splice(@a,0,0,$x,$y)

    $a[$x] = $y         splice(@a,$x,1,$y);

Przyk³ad, przy za³o¿eniu, ¿e d³ugo¶ci tablic s± przekazywane przed tablicami:

    sub aeq {   # porównaj dwie warto¶ci listowe

        local(@a) = splice(@_,0,shift);

        local(@b) = splice(@_,0,shift);

        return 0 unless @a == @b;       # ta sama d³ugo¶æ?

        while (@a) {

            return 0 if pop(@a) ne pop(@b);

        }

        return 1;

    }

    if (&aeq($len,@foo[1..$len],0+@bar,@bar)) { ... }

split /WZORZEC/,WYRA¯,LIMIT

split /WZORZEC/,WYRA¯

split /WZORZEC/

split

Dzieli ³añcuch na tablicê ³añcuchów i zwraca tê tablicê.

Je¶li nie jest w kontek¶cie listowym, to zwraca listê znalezionych pól i dzieli do tablicy @_. (w kontek¶cie listowym mo¿esz wymusiæ dzielenie do @_, u¿ywaj±c jako rozdzielaczy wzorca ??, lecz bêdzie wci±¿ zwracaæ warto¶æ tablicow±.) U¿ywanie jawnego dzielenia do @_ nie jest jednak zalecane.

Je¶li WYRA¯ jest pominiêty, dzielony jest ³añcuch $_. Je¶li pominiêty jest te¿ WZORZEC, dzielenie nastêpuje na bia³ych spacjach (po pominiêciu wszelkich prowadz±cych bia³ych spacji). Wszystko, odpowiadaj±ce WZORCOWI jest uwa¿ane za rozdzielacz pól. (Zauwa¿, ¿e rozdzielacz mo¿e byæ d³u¿szy ni¿ jeden znak.) Je¶li podano warto¶æ LIMIT i nie jest to liczba ujemna, dzielenie nastêpuje do nie wiêcej ni¿ tej ilo¶ci pól. Je¶li LIMIT nie jest podany, koñcz±ce wype³nienia nullowe s± obcinane (co dobrze pamiêtaæ u¿ytkownikom pop()). Je¶li LIMIT jest ujemny, to jest traktowany tak, jakby podano arbitralnie du¿y LIMIT.

Wzorzec, odpowiadaj±cy ³añcuchowi null (¿eby nie byæ zmylonym ze wzorcem null //, który jest tylko jednym cz³onkiem z zestawu wzorców odpowiadaj±cych ³añcuchowi null) bêdzie dzieli³ warto¶æ WYRA¯ na oddzielne znaki w ka¿dym punkcie, który odpowie zapytaniu. Na przyk³ad:

    print join(':', split(/ */, 'hi there'));

da w wyniku `h:i:t:h:e:r:e'.

Parametr LIMIT mo¿e byæ u¿yty do podzielenia linii czê¶ciowo

    ($login, $passwd, $remainder) = split(/:/, $_, 3);

Podczas przypisywania do listy, je¶li nie podano LIMITU, perl ustawia domy¶lny limit wielko¶ci o 1 wiêkszej ni¿ lista zmiennych na li¶cie, zapobiegaj±c tak niepotrzebnej pracy. Dla powy¿szej listy, LIMIT by³by ustawiony domy¶lnie na 4. W aplikacjach, gdzie czas jest krytycznym czynnikiem, powstrzymuje ciê to od dzielenia na wiêcej pól, ni¿ rzeczywi¶cie potrzebujesz.

Je¶li WZORZEC zawiera nawiasy, z ³añcuchów odpowiadaj±cym pod³añcuchom rozdzielacza tworzone s± dodatkowe elementy tablicy.

    split(/([,-])/, "1-10,20", 3);

daje warto¶æ listow±

    (1, '-', 10, ',', 20)

Je¶li masz ca³y nag³ówek normalnego unixowego komunikatu pocztowego w nag³ówku $header, to mo¿esz rozdzieliæ go na pola i warto¶ci w nastêpuj±cy sposób:

    $header =~ s/\n\s+/ /g;  # obs³u¿ linie kontynuacji

    %hdrs   =  (UNIX_FROM => split /^(.*?):\s*/m, $header);

Wzorzec /WZORZEC/ mo¿e byæ zamieniony wyra¿eniem, umo¿liwiaj±c tak podawanie wzorców, które zmieniaj± siê w czasie. (aby dokonaæ kompilacji czasu dzia³ania tylko raz, u¿yj /$variable/o.)

Specjalnym przypadkiem jest podanie jako WZORZEC spacji (' '). Bêdzie to powodowaæ dzielenie na bia³ych spacjach, podobnie jak domy¶lna wersja split. Tak wiêc split(' `) mo¿e byæ u¿ywany do domy¶lnego zachowania awk, gdzie split(/ /) daje tyle ³añcuchów null, ile jest prowadz±cych bia³ych spacji. Split dla /\s+/ jest podobny do split(' `), lecz dowolna bia³a spacja powoduje null na pierwszym polu. Split bez argumentów dokonuje w rzeczywisto¶ci wewnêtrznie split(' ', $_).

Przyk³ad:

    open(passwd, '/etc/passwd');

    while (<passwd>) {

        ($login, $passwd, $uid, $gid, $gcos,

            $home, $shell) = split(/:/);

        ...

    }

(Zauwa¿, ¿e $shell w powy¿szym bêdzie mia³ za sob± now± liniê. Aby j± usun±æ, zapoznaj siê z funkcjami chop, chomp i join, opisanymi gdzie¶ w tym dokumencie.)

sprintf FORMAT, LISTA

Zwraca ³añcuch, sformatowany wed³ug konwencji printf, funkcji bibliotecznej jêzyka C, sprintf(3).

Perl emuluje funkcjê C sprintf(), lecz nie u¿ywa jej (poza liczbami zmiennoprzecinkowymi, a nawet wtedy dozwolone s± tylko standardowe modyfikatory). W wyniku, w perlu nie s± dostêpne ¿adne niestandardowe rozszerzenia lokalnej wersji sprintf().

Perlowy sprintf() zezwala na nastêpuj±ce, ogólnie znane konwersje:

   %%   znak procentu

   %c   znak o podanym kodzie

   %s   ³añcuch

   %d   integer ze znakiem, dziesiêtnie

   %u   integer bez znaku, dziesiêtnie

   %o   integer bez znaku, ósemkowo

   %x   integer bez znaku, szesnastkowo

   %e   liczba zmiennoprzecinkowa w notacji naukowej

   %f   liczba zmiennoprzecinkowa w ustalonej notacji dziesiêtnej

   %g   liczba zmiennoprzecinkowa w notacji %e lub %f

Dodatkowo, perl zezwala na nastêpuj±ce szeroko-obs³ugiwane konwersje:

   %X   podobne do %x, lecz na du¿ych literach

   %E   podobne do %e, lecz z u¿yciem du¿ego E

   %G   podobne do %g, lecz z u¿yciem du¿ego E

   %p   wska¼nik (daje adres warto¶ci, podany szesnastkowo)

   %n   specjalne: przechowuje liczbê dotychczas wpisanych do nastêpnej

        zmiennej z listy parametrów

I w koñcu, dla kompatybilno¶ci wstecznej, perl zezwala na poni¿sze zbyteczne, lecz szeroko obs³ugiwane konwersje:

   %i   synonim %d

   %D   synonim %ld

   %U   synonim %lu

   %O   synonim %lo

   %F   synonim %f

Perl zezwala na u¿ycie nastêpuj±cych uniwersalnych flag miêdzy znakiem %, a liter± konwersji:

   spacja  poprzed¼ liczbê dodatni± spacj±

   +       poprzed¼ liczbê dodatni± plusem

   -       wyrównuj do lewej w obszarze pola

   0       u¿yj zer zamiast spacji do wyrównywania w prawo

   #       poprzed¼ liczbê ósemkow± "0", szesnastkow± "0x"

   liczba  minimalna wielko¶æ pola

   .liczba "precyzja": liczba cyfr po kropce dziesiêtnej dla

           zmiennoprzecinkowych, maksymalna d³ugo¶æ dla ³añcucha, lub 

           minimalna d³ugo¶æ dla liczby ca³kowitej (integer)

   l       interpretuj integer jak typ C "long", lub "unsigned long"

   h       interpretuj integer jak typ C "short", lub "unsigned short"

Istnieje te¿ jedna flaga specyficzna dla perla:

   V       interpretuj integer jako standardowy typ integera w perlu

Tam, gdzie we flagach pojawia siê liczba, mo¿na u¿yæ gwiazdki ("*"). W tym wypadku perl u¿ywa zamiast liczby warto¶ci nastêpnego argumentu z listy parametrów. Je¶li szeroko¶æ pola, uzyskana przez ``*'' jest ujemna, to ma to samo dzia³anie, co flaga `-': wyrównywanie do lewej.

Je¶li dzia³a use locale, znaki u¿ywane do kropki dziesiêtnej bêd± drukowane wed³ug locale LC_NUMERIC. Zobacz stronê perllocale(1).

sqrt WYRA¯

sqrt

Zwraca pierwiastek kwadratowy z WYRA¯. Je¶li WYRA¯ jest pominiête, zwraca warto¶æ dla $_.

srand WYRA¯

srand

Ustawia nasionko liczby losowej dla operatora rand. Je¶li pominiête zostanie WYRA¯, u¿ywana jest pseudolosowa warto¶æ, oparta o bie¿±cy czas i identyfikator procesu. W wersjach perla wcze¶niejszych ni¿ 5.004, domy¶lnym nasionkiem by³ po prostu bie¿±cy czas time(). Nie jest to szczególnie dobre nasionko, wiêc wiele starych programów za³±cza³o swoj± w³asn± warto¶æ inicjuj±c± (czêsto time ^ $$, lub C<time ^ ($$ + ($$ << 15))>), lecz teraz nie jest to konieczne.

W rzeczywisto¶ci, zazwyczaj w ogóle nie jest konieczne wywo³ywanie srand, poniewa¿ jest ono wywo³ywane niejawnie przy pierwszym u¿yciu operatora rand. Jednak nie by³o tak w wersjach wcze¶niejszych ni¿ perl 5.005, wiêc je¶li twój skrypt ma dzia³aæ ze starszymi wersjami, powinien jednak wo³aæ srand().

Zauwa¿, ¿e dla potrzeb kryptografii potrzebujesz czego¶ wiêcej ni¿ tylko wylosowaæ domy¶lne nasionko. Popularn± metod± jest sprawdzanie sum kontrolnych skompresowanego wyj¶cia z jednego, lub wiêcej programów szybko zmieniaj±cego siê statusu systemu operacyjnego. Na przyk³ad:

    srand (time ^ $$ ^ unpack "%L*", `ps axww | gzip`);

Je¶li naprawdê ci na tym zale¿y, zobacz modu³ Math::TrulyRandom w CPAN.

Nie wo³aj srand() wielokrotnie, chyba ¿e dok³adnie wiesz co i w jakim celu robisz. Celem tej funkcji jest zasilenie funkcji rand() tak, by rand() zwraca³ inn± sekwencjê dla ka¿dego uruchomienia programu. Zrób to raz, na samym pocz±tku programu, bo w przeciwnym wypadku nie uzyskasz z rand() liczb losowych!

Czêsto wywo³ywane programy (takie jak skrypty CGI), które jako nasionka u¿ywaj± po prostu

    time ^ $$

mog± pa¶æ ofiar± w³asno¶ci matematycznej, ¿e

    a^b == (a+1)^(b+1)

przez jedn± trzeci± czasu. Wiêc nie rób tego.

stat UCHWYTPLIKU

stat WYRA¯

stat

Zwraca 13 elementow± tablicê, opisuj±c± status pliku--otwartego przez UCHWYTPLIKU lub nazwanego przez WYRA¯. Je¶li WYRA¯ jest pominiête, u¿ywany jest $_. Gdy funkcja zawiedzie, zwraca listê null. Zazwyczaj jest to u¿ywane nastêpuj±co:

    ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,

       $atime,$mtime,$ctime,$blksize,$blocks)

           = stat($filename);

Nie wszystkie z tych pól s± obs³ugiwane na wszystkich rodzajach systemów plików. Oto znaczenia pól:

  0 dev      numer urz±dzenia systemu plików

  1 ino      numer inode

  2 mode     prawa pliku (typ i prawa)

  3 nlink    liczba twardych dowi±zañ do pliku

  4 uid      numeryczny UID w³a¶ciciela

  5 gid      numeryczny GID w³a¶ciciela

  6 rdev     identyfikator urz±dzenia (tylko dla plików specjalnych)

  7 size     ca³kowity rozmiar w bajtach

  8 atime    ostatni dostêp od epoki

  9 mtime    ostatnia modyfikacja od epoki

 10 ctime    ostatnia zmiana inode od epoki

 11 blksize  preferowany rozmiar bloku dla I/O systemu plików

 12 blocks   rzeczywista liczba zaalokowanych bloków

(Epoka nast±pi³a o 00:00 1 stycznia, 1970 GMT.)

Je¶li funkcja dostanie specjalny uchwyt pliku, sk³adaj±cy siê z podkre¶lenia, to nie jest ona wykonywana, lecz przekazywana jest zawarto¶æ ostatniego testu pliku. Przyk³ad:

    if (-x $file && (($d) = stat(_)) && $d < 0) {

        print "$file jest wykonywalnym plikiem NFS\n";

    }

(Dzia³a to tylko na maszynach, dla których numer urz±dzenia jest ujemny dla NFS.)

study SKALAR

study

Zajmuje trochê czasu, by przestudiowaæ SKALAR (lub $_, je¶li go nie podano), przygotowuj±c siê na wiele przeszukiwañ wzorców na tym ³añcuchu, przed jego kolejn± modyfikacj±. Mo¿e to pozwoliæ zyskaæ na czasie, zale¿nie od natury i liczby wzorców, a tak¿e od roz³o¿enia czêstotliwo¶ci znaków w przeszukiwanym ³añcuchu. Najlepiej sprawdziæ empirycznie, czy funkcja ta wp³ywa na szybko¶æ dodatnio, czy ujemnie. Najwiêcej zyskaj± pêtle, szukaj±ce wielu krótkich, sta³ych ³añcuchów (w³±czaj±c sta³e czê¶ci bardziej z³o¿onych wzorców). Naraz mo¿na mieæ obs³ugiwany przez study tylko jeden ³añcuch. Je¶li przejdziesz na inny skalar, to poprzedni stanie siê nieprzestudiowany. (study dzia³a nastêpuj±co: najpierw robiona jest lista powi±zana dla ka¿dego znaku przeszukiwanego ³añcucha, tak ¿e wiemy na przyk³ad gdzie znajduj± siê wszystkie znaki `k'. W ka¿dym szukanym ³añcuchu wybierany jest w oparciu o statyczne tablice rozk³adu najrzadziej wystêpuj±cy znak. £añcuch jest poszukiwany w miejscach, gdzie znajduje siê ten najrzadszy znak.)

Na przyk³ad oto pêtla, która wstawia wpisy tworz±ce indeks przed ka¿d± liniê, zawieraj±c± okre¶lony wzorzec:

    while (<>) {

        study;

        print ".IX foo\n" if /\bfoo\b/;

        print ".IX bar\n" if /\bbar\b/;

        print ".IX blurfl\n" if /\bblurfl\b/;

        ...

        print;

    }

U¿ycie study spowoduje szukanie /\bfoo\b/ tylko w miejscach $_, które zawieraj± ``f'', gdy¿ jest to najrzadszy znak. Ogólnie, daje to du¿e zyski, poza przypadkami patologicznymi. Jedynym pytaniem jest to, czy zachowuje ci to wiêcej czasu ni¿ zabra³o zbudowanie powi±zanej listy.

Zauwa¿, ¿e je¶li musisz szukaæ ³añcuchów, o których nic nie wiesz, a¿ do uruchomienia, to mo¿esz zbudowaæ ca³± pêtlê jako ³añcuch i evalowaæ to, by zapobiec ci±g³emu rekompilowaniu wzorców. W po³±czeniu z czynieniem $/ niezdefiniowanym, aby wessaæ ca³e pliki jako jeden rekord, mo¿e to byæ bardzo szybkie, czêsto szybsze ni¿ specjalizowane programy typu fgrep(1). Nastêpuj±cy przyk³ad skanuje listê plików (@files) w poszukiwaniu listy s³ów (@words) i drukuje nazwy plików, zawieraj±cych odpowiednik:

    $search = 'while (<>) { study;';

    foreach $word (@words) {

        $search .= "++\$seen{\$ARGV} if /\\b$word\\b/;\n";

    }

    $search .= "}";

    @ARGV = @files;

    undef $/;

    eval $search;               # to krzyczy

    $/ = "\n";          # ustaw normalny rozdzielacz wej¶cia

    foreach $file (sort keys(%seen)) {

        print $file, "\n";

    }

sub BLOK

sub NAZWA

sub NAZWA BLOK

Nie jest to prawdziwa funkcja, lecz definicja podprocedury. Je¶li zawiera tylko NAZWÊ (i przypuszczalnie prototypy), jest to tylko deklaracja. Bez NAZWY jest to deklaracja anonimowej funkcji i zwraca warto¶æ: referencjê CODE zawê¿enia, które w³a¶nie utworzy³e¶. Dla dalszych szczegó³ów, zobacz stronê podrêcznika perlref(1).

substr WYRA¯,OFFSET,D£UGO¦Æ

substr WYRA¯,OFFSET

Wyci±ga z WYRA¯ pod³añcuch i zwraca go. Pierwszy znak znajduje siê pod offsetem 0, lub tym, na co ustawi³e¶ $[ (lecz nie rób tego). Je¶li OFFSET jest ujemny, rozpoczyna siê w tej odleg³o¶ci od koñca ³añcucha. Je¶li D£UGO¦Æ jest pominiêta, zwracane jest wszystko, a¿ do koñca ³añcucha. Je¶li D£UGO¦Æ jest ujemna, pozostawia tyle znaków z koñca ³añcucha.

Funkcji substr() mo¿esz u¿yæ jako lwarto¶ci, w którym wypadku WYRA¯ musi byæ lwarto¶ci±. Je¶li przyznasz co¶ krótszego ni¿ D£UGO¦Æ, ³añcuch zostanie skrócony, a je¶li co¶ d³u¿szego, to ³añcuch zostanie rozci±gniêty. Aby zachowaæ sta³± d³ugo¶æ ³añcucha, mo¿esz potrzebowaæ dope³niæ, lub obci±æ warto¶ci przy u¿yciu sprintf().

symlink STARYPLIK,NOWYPLIK

Tworzy now± nazwê pliku, dowi±zan± symbolicznie do starej. Po sukcesie zwraca 1, w przeciwnym wypadku 0. Na systemach nie obs³uguj±cych dowi±zañ symbolicznych, funkcja ta powoduje b³±d krytyczny podczas dzia³ania. Aby go wychwyciæ, u¿yj eval:

    $symlink_exists = (eval {symlink("","")};, $@ eq '');

syscall LISTA

Wywo³uje wywo³anie systemowe, podane jako pierwszy element listy, przekazuj±c resztê elementów jako argumenty wywo³ania. Je¶li nie jest to zaimplementowane, powoduje b³±d krytyczny. Argumenty s± interpretowane nastêpuj±co: je¶li podany argument jest numeryczny, przekazywany argument to int. Je¶li nie, przekazywany jest wska¼nik do warto¶ci tekstowej. Odpowiadasz za upewnienie siê, ¿e ³añcuch jest do¶æ d³ugi, by odebraæ okre¶lony wynik, który mo¿e byæ do niego zapisany. Je¶li twoje argumenty int nie s± litera³ami i nie by³y nigdy interpretowane w kontek¶cie numerycznym, mo¿esz byæ zmuszonym dodaæ do nich 0, aby wymusiæ na nich wygl±d liczbowy.

    require 'syscall.ph';               # mo¿e byæ niezbêdne h2ph

    syscall(&SYS_write, fileno(STDOUT), "hi there\n", 9);

Zauwa¿, ¿e perl obs³uguje przekazywanie do 14 argumentów do wywo³ania systemowego, co w praktyce powinno wystarczyæ.

sysopen UCHWYTPLIKU,NAZWAPLIKU,TRYB

sysopen UCHWYTPLIKU,NAZWAPLIKU,TRYB,PRAWA

Otwiera plik NAZWAPLIKU i wi±¿e go z UCHWYTEMPLIKU. Je¶li UCHWYTPLIKU jest wyra¿eniem, to jego warto¶æ jest u¿ywana jako nazwa rzeczywistego uchwytu pliku. Funkcja ta wo³a podlegaj±c± jej funkcjê systemu operacyjnego, open z parametrami NAZWAPLIKU, TRYB, PRAWA.

Prawid³owe warto¶ci i bity flag parametru TRYB s± zale¿ne od systemu; s± one dostêpne przez standardowy modu³ Fcntl. Jednak z przyczyn historycznych, niektóre warto¶ci s± uniwersalne; zero oznacza tylko dla odczytu, jeden tylko dla zapisu, a dwa dla zapisu i odczytu.

Je¶li plik NAZWAPLIKU nie istnieje, a wywo³anie open go tworzy (zazwyczaj dlatego, ¿e TRYB zawiera flagê O_CREAT), to warto¶æ PRAW okre¶la prawa nowo utworzonego pliku. Je¶li s± one pominiête, u¿ywana jest domy¶lna warto¶æ 0666, która umo¿liwia wszystkim odczyt i zapis. Warto¶æ ta ma sens, zobacz umask.

Modu³ IO::File daje bardziej obiektowe podej¶cie do tych rzeczy.

sysread UCHWYTPLIKU,SKALAR,D£UGO¦Æ,OFFSET

sysread UCHWYTPLIKU,SKALAR,D£UGO¦Æ

Próbuje odczytaæ D£UGO¦Æ bajtów danych do zmiennej SKALAR. Odczyt nastêpuje z pliku wskazywanego przez UCHWYTPLIKU, przy u¿yciu wywo³ania systemowego read(2). Pomija to stdio, wiêc ³±czenie tej funkcji z innym rodzajami odczytu, z print(), write(), seek(), lub tell() mo¿e powodowaæ problemy. Zwraca ilo¶æ odczytanych bajtów, lub undef w wypadku b³êdu. SKALAR bêdzie rozci±gany tak, by pasowa³ do liczby odczytanych bajtów.

Aby spowodowaæ odczyt danych z którego¶ miejsca ³añcucha (ró¿nego ni¿ pocz±tek), mo¿na podaæ dodatkowo parametr OFFSET. Je¶li parametr ten jest ujemny, to wskazywana jest pozycja przesuniêta o tyle¿ bajtów w ty³ od koñca ³añcucha. Je¶li dodatni offset jest wiêkszy od d³ugo¶ci SKALARA, to wynikiem jest wype³nienie do wymaganego rozmiaru znakami ``\-'', a nastêpnie doklejenie odczytu.

sysseek UCHWYTPLIKU,POZYCJA,GDZIE

Zmienia pozycjê UCHWYTUPLIKU przy u¿yciu wywo³ania systemowego lseek(2). Pomija stdio, wiêc ³±czenie tego z odczytami (innymi ni¿ sysread()), z print(), write(), seek(), lub tell() mo¿e wprowadziæ problemy. UCHWYTPLIKU mo¿e byæ wyra¿eniem, którego warto¶æ daje nazwê uchwytu pliku. Warto¶ci dla GDZIE to 0 dla ustawienia nowej pozycji, 1 dla dodania nowej pozycji do bie¿±cej i 2 do ustawienia pozycji EOF plus offset. Dla parametru GDZIE mo¿na u¿ywaæ sta³ych SEEK_SET, SEEK_CUR i SEEK_END z modu³u IO::Seekable lub POSIX.

Zwracana jest nowa pozycja, lub warto¶æ niezdefiniowana w wypadku b³êdu. Pozycja zerowa zwracana jest jako ³añcuch ``0 but true''; tak wiêc sysseek() zwraca TRUE po sukcesie i FALSE po b³êdzie, lecz wci±¿ mo¿esz ³atwo ustaliæ now± pozycjê.

system LISTA

Robi dok³adnie to samo, co ``exec LISTA'', poza tym, ¿e dokonuje przed tym forka i proces rodzicielski czeka, a¿ dziecko dokona ¿ywota. Zauwa¿, ¿e przetwarzanie argumentów ró¿ni siê, zale¿nie od liczby argumentów. Warto¶æ zwracana jest statusem wyj¶cia programu, zwróconym przez wywo³anie wait(). Aby uzyskaæ rzeczywist± warto¶æ wyj¶cia, podziel j± przez 256. Zobacz te¿ opis exec, znajduj±cy siê gdzie¶ w tym dokumencie. Nie jest to sposób, którego nale¿y u¿ywaæ do przechwytywania wyj¶cia z komendy, dla tego celu u¿yj zwyk³ych odwróconych apostrofów (backticks?) lub qx//, jak opisano w sekcji `£AÑCUCH` podrêcznika perlop(1).

Poniewa¿ zarówno system() i odwrotne apostrofy blokuj± SIGINT i SIGQUIT, ubicie ich nie powoduje przerwania twojego programu.

    @args = ("command", "arg1", "arg2");

    system(@args) == 0

         or die "system @args siê nie powiód³: $?"

A oto bardziej wyrafinowany przyk³ad analizowania warto¶ci zwracanej przez system(). Ma to miejsce na systemie unixowym i jest robione, aby sprawdziæ wszystkie mo¿liwo¶ci, w³±cznie z sygna³ami i zrzutami core.

    $rc = 0xffff & system @args;

    printf "system(%s) zwróci³ %#04x: ", "@args", $rc;

    if ($rc == 0) {

        print "normalne zakoñczenie\n";

    }

    elsif ($rc == 0xff00) {

        print "komenda siê nie powiod³a: $!\n";

    }

    elsif ($rc > 0x80) {

        $rc >>= 8;

        print "niezerowy status wyj¶cia $rc\n";

    }

    else {

        print "skoñczy³ z ";

        if ($rc &   0x80) {

            $rc &= ~0x80;

            print "zrzutem core z ";

        }

        print "sygna³em $rc\n"

    }

    $ok = ($rc != 0);

syswrite UCHWYTPLIKU,SKALAR,D£UGO¦Æ,OFFSET

syswrite UCHWYTPLIKU,SKALAR,D£UGO¦Æ

Próbuje zapisaæ D£UGO¦Æ bajtów ze SKALARA do pliku podanego przez UCHWYTPLIKU przy u¿yciu wywo³ania systemowego write(2). Pomija stdio, wiêc ³±czenie tego z odczytami (innymi ni¿ sysread()), z print(), write(), seek(), lub tell() mo¿e spowodowaæ problemy. Zwraca liczbê zapisanych bajtów, lub undef w wypadku b³êdu. Je¶li d³ugo¶æ jest wiêksza ni¿ dostêpne dane, zapisywanych jest tylko tyle danych, ile jest dostêpnych.

Dodatkowo mo¿na podaæ OFFSET, aby zapisaæ dane z jakiej¶ czê¶ci ³añcucha, która nie jest pocz±tkiem. Ujemna warto¶æ offsetu nakazuje zapisywanie od miejsca, przesuniêtego o tyle bajtów od koñca ³añcucha.

tell UCHWYTPLIKU

tell

Zwraca bie¿±c± pozycjê pliku dla UCHWYTUPLIKU. UCHWYTPLIKU mo¿e byæ wyra¿eniem, którego warto¶æ podaje nazwê rzeczywistego uchwytu pliku. Je¶li UCHWYTPLIKU jest pominiêty, zak³adany jest plik, z którego ostatnio czytano.

telldir UCHWYTKATALOGU

Zwraca bie¿±c± pozycjê funkcji readdir() dla UCHWYTUKATALOGU. Do seekdir() mo¿na przekazaæ warto¶æ, ka¿±c± osi±gn±c okre¶lon± pozycjê w katalogu.

tie ZMIENNA,NAZWAKLASY,LISTA

Funkcja ta ³±czy zmienn± z klas± pakietu, która opisuje jej implementacjê. ZMIENNA jest nazw± czarowanej zmiennej. NAZWAKLASY jest nazw± klasy, implementuj±cej obiekty w³a¶ciwego typu. Wszelkie dodatkowe argumenty s± przekazywane metodzie ``new'' klasy (czyli TIESCALAR, TIEARRAY, lub TIEHASH). Zazwyczaj, argumenty te wygl±daj± tak, jak te, które s± przekazywane funkcji dbm_open() z C. Obiekt, zwrócony przez metodê ``new'' jest te¿ zwracany przez tie(), co jest przydatne, je¶li chcesz dostaæ siê do innych metod w NAZWIEKLASY.

Zauwa¿, ¿e funkcje takie, jak keys() i valuse() mog± zwracaæ wielkie warto¶ci tablicowe, je¶li u¿yæ je na du¿ych obiektach, takich jak pliki DBM. Lepiej mo¿e byæ u¿yæ funkcji each() i na nich iterowaæ. Przyk³ad:

    # drukuj offsety pliku historii

    use NDBM_File;

    tie(%HIST, 'NDBM_File', '/usr/lib/news/history', 1, 0);

    while (($key,$val) = each %HIST) {

        print $key, ' = ', unpack('L',$val), "\n";

    }

    untie(%HIST);

Klasa, implementuj±ca tablicê asocjacyjn±, powinna mieæ nastêpuj±ce metody:

    TIEHASH classname, LIST

    DESTROY this

    FETCH this, key

    STORE this, key, value

    DELETE this, key

    EXISTS this, key

    FIRSTKEY this

    NEXTKEY this, lastkey

Klasa, implementuj±ca zwyk³± tablicê, powinna mieæ nastêpuj±ce metody:

    TIEARRAY classname, LIST

    DESTROY this

    FETCH this, key

    STORE this, key, value

    [others TBD]

Klasa, implementuj±ca skalar, powinna mieæ nastêpuj±ce metody:

    TIESCALAR classname, LIST

    DESTROY this

    FETCH this,

    STORE this, value

W przeciwieñstwie do funkcji dbmopen(), funkcja tie() nie u¿ywa, lub wymaga dla ciebie modu³ów (use, require)---musisz o to zadbaæ samodzielnie. Zobacz podrêcznik DB_File oraz modu³ Config dla interesuj±cych implementacji tie().

tied ZMIENNA

Zwraca referencjê do obiektu kryj±cego siê pod ZMIENN¡ (warto¶æ, która by³a pocz±tkowo zwrócona przez tie(), które powi±za³ zmienn± z pakietem.) Gdy ZMIENNA nie jest powi±zana, zwracana jest warto¶æ niezdefiniowana.

time

Zwraca liczbê sekund od pocz±tku epoki (tj. na MacOs od 00:00:00, 1 Stycznia, 1904, a od 00:00:00 UTC, 1 Stycznia, 1970 dla wiêkszo¶ci innych systemów). Wystarczaj±ce do przekazania dla gmtime() lub localtime().

times

Zwraca czteroelementow± tablicê, podaj±c± w sekundach czasy u¿ytkownika i systemu. Warto¶ci s± dla tego procesu, oraz dla dzieci tego procesu.

    ($user,$system,$cuser,$csystem) = times;

tr///

Operator translacji. To samo co y///. Zobacz stronê perlop(1).

truncate UCHWYTPLIKU,D£UGO¦Æ

truncate WYRA¯,D£UGO¦Æ

Skraca plik, otwarty na UCHWYCIEPLIKU lub nazwany przez WYRA¯ do podanej d³ugo¶ci. Na systemach, gdzie nie jest to zaimplementowane, powoduje b³±d krytyczny.

uc WYRA¯

uc

Zwraca WYRA¯ w du¿ych literach. Jest to funkcja wewnêtrzna, implementuj±ca escape \U na ³añcuchach ujêtych w podwójne cudzys³owy. Szanuje bie¿±ce ustawienie LC_CTYPE, je¶li w³±czono use locale. Zobacz podrêcznik perllocale(1).

Je¶li WYRA¯ jest pominiête, u¿ywa $_.

ucfirst WYRA¯

ucfirst

Zwraca WYRA¯, z pierwszym znakiem zmienionym na du¿± literê. Jest to funkcja wewnêtrzna, implementuj±ca escape \u na ³añcuchach ujêtych w cudzys³owy. Szanuje bie¿±ce ustawienie LC_CTYPE, je¶li w³±czono use locale. Zobacz podrêcznik perllocale(1).

If EXPR is omitted, uses $_.

umask WYRA¯

umask

Ustawia umaskê procesu na WYRA¯ i zwraca warto¶æ poprzedni±. Je¶li WYRA¯ jest pominiête, po prostu zwraca bie¿±c± umaskê. Pamiêtaj, ¿e umaska jest liczb±, zazwyczaj podawan± ósemkowo; nie jest ³añcuchem cyfr ósemkowych. Zobacz opis oct, znajduj±cy siê gdzie¶ w tym dokumencie, je¶li masz tylko ³añcuch.

undef WYRA¯

undef

Powoduje, ¿e warto¶æ WYRA¯, która musi byæ lwarto¶ci±, staje siê niezdefiniowana. U¿ywaj tego tylko na warto¶ciach skalarnych, ca³ej tablicy, ca³ej tablicy asocjacyjnej, lub na nazwie podprocedury (przy u¿yciu ``&"). (U¿ywanie tej funkcji w innych wypadkach przypuszczalnie nie doprowadzi do takich rezultatów, jakich mo¿na by oczekiwaæ.) Zawsze zwraca warto¶æ niezdefiniowan±. Mo¿esz pomin±æ WYRA¯--w tym wypadku nic nie jest pozbawiane zdefiniowania, lecz mimo to uzyskujesz warto¶æ niezdefiniowan±, któr± mo¿esz np. zwróciæ z podprocedury, przypisaæ zmiennej,lub przekazaæ jako parametr. Przyk³ady:

    undef $foo;

    undef $bar{'blurfl'};             # Porównaj z: delete $bar{'blurfl'};

    undef @ary;

    undef %hash;

    undef &mysub;

    return (wantarray ? (undef, $errmsg) : undef) if $they_blew_it;

    select undef, undef, undef, 0.25;

    ($a, $b, undef, $c) = &foo;       # Ignoruj trzeci± zwrócon± warto¶æ

unlink LISTA

unlink

Kasuje listê plików. Zwraca liczbê skasowanych plików.

    $cnt = unlink 'a', 'b', 'c';

    unlink @goners;

    unlink <*.bak>;

Uwaga: unlink nie skasuje katalogów, chyba ¿e jeste¶ superu¿ytkownikiem i przekaza³e¶ perlowi flagê -U. Nawet gdy te warunki s± spe³nione, b±d¼ ostrze¿ony, ¿e skasowanie katalogu mo¿e wywo³aæ uszkodzenie systemu plików. Zamiast tego u¿yj rmdir.

Je¶li LISTA jest pominiêta, u¿ywa $_.

unpack WZORZEC,WYRA¯

Unpack robi odwrotno¶æ tego, co pack: pobiera ³añcuch, reprezentuj±cy strukturê i rozwija go na listê warto¶ci, zwracaj± warto¶æ tablicow± (w kontek¶cie skalarnym zwraca tylko pierwsz± warto¶æ tablicy). WZORZEC jest tego samego formatu co dla funkcji pack. Oto podprocedura, która dokonuje substringu:

    sub substr {

        local($what,$where,$howmuch) = @_;

        unpack("x$where a$howmuch", $what);

    }

a potem mamy

    sub ordinal { unpack("c",$_[0]); } # to samo co ord()

Dodatkowo, mo¿esz poprzedziæ pola %<liczb±>, wskazuj±c, ¿e chcesz <liczba>-bitow± sumê szesnastkow± elementów, zamiast samych elementów. Domy¶lna jest suma 16-bitowa. Na przyk³ad, nastêpuj±cy przyk³ad oblicza tê sam± liczbê co program sum z Systemu V:

    while (<>) {

        $checksum += unpack("%16C*", $_);

    }

    $checksum %= 65536;

Nastêpuj±cy fragment efektywnie oblicza liczbê ustawionych bitów w wektorze bitowym:

    $setbits = unpack("%32b*", $selectmask);

untie ZMIENNA

Rozbija powi±zanie miêdzy zmienn±, a pakietem. Zobacz tie().

unshift TABLICA,LISTA

Robi odwrotn± rzecz do shift. Lub odwrotn± do push, zale¿nie jak na to spojrzeæ. Dokleja listê do pocz±tku tablicy i zwraca now± liczbê elementów.

    unshift(ARGV, '-e') unless $ARGV[0] =~ /^-/;

Zauwa¿, ¿e LISTA jest doklejana ca³a, a nie jeden element naraz, wiêc doklejone elementy pozostaj± w tej samej kolejno¶ci. Aby j± odwróciæ, u¿yj reverse.

use Module LISTA

use Module

use Module WERSJA LISTA

use WERSJA

Importuje semantykê danego modu³u do bie¿±cego pakietu. Ogólnie aliasuje okre¶lone podprocedury lub nazwy zmiennych do twojego pakietu. Jest to dok³adnie równowa¿ne

    BEGIN { require Module; import Module LIST; }

poza tym, ¿e Module musi byæ go³ym s³owem.

Je¶li pierwszy argument use jest liczb±, to jest ona traktowana jako numer wersji, zamiast nazwa modu³u. Je¶li wersja interpretera perla jest mniejsza ni¿ WERSJA, to wy¶wietlony zostanie komunikat o b³êdzie, a perl natychmiast zakoñczy dzia³anie. Jest to czêsto przydatne, je¶li chcesz sprawdziæ wersjê perla przed u¿ywaniem modu³ów bibliotecznych, które zmieni³y siê w sposób niekompatybilny od czasu starszych wersji perla. (staramy siê by tak nie by³o.)

S³owo BEGIN wymusza by require i import zasz³y podczas kompilacji. Require zapewnia, ¿e modu³ bêdzie za³adowany do pamiêci, je¶li wcze¶niej nie by³. Import nie jest wbudowany---jest to tylko zwyk³e, statyczne wywo³anie metody pakietu ``Module'' aby powiedzieæ modu³owi, by zaimportowa³ listê w³a¶ciwo¶ci do pakietu bie¿±cego. Modu³ mo¿e implementowaæ swoj± metodê import w dowolny sposób, choæ wiêkszo¶æ modu³ów woli wyprowadzaæ swoj± metodê poprzez dziedziczenie z klasy Exporter, zdefiniowanej w module Exporter, Zobacz podrêcznik Exporter. Je¶li nie ma ¿adnej metody importuj±cej, to b³±d jest cicho ignorowany. Mo¿e siê to w przysz³ych wersjach zmieniæ na b³±d krytyczny.

Je¶li nie chcesz zmieniania swojej przestrzeni nazw, za³±cz jawnie pust± listê:

    use Module ();

Jest to dok³adnie równowa¿ne

    BEGIN { require Module; }

Je¶li miêdzy Module, a LISTA jest obecny argument WERSJA, to use wywo³a metodê VERSION klasy Module z podan± wersj±, jako argumentem. Domy¶lna metoda VERSION, dziedziczona z klasy Universal, zakracze je¶li podana wersja jest wiêksza ni¿ warto¶æ zmiennej $Module::VERSION. (Zauwa¿, ¿e nie ma przecinka po WERSJI!)

Poniewa¿ jest to szeroko otwarty interfejs, mo¿na tak implementowaæ te¿ pragmy (dyrektywy kompilatora). Obecnie zaimplementowane pragmy to:

    use integer;

    use diagnostics;

    use sigtrap qw(SEGV BUS);

    use strict  qw(subs vars refs);

    use subs    qw(afunc blurfl);

Te pseudo modu³y importuj± semantykê do bie¿±cego zakresu bloku, w przeciwieñstwie do zwyk³ych modu³ów, które importuj± symbole do bie¿±cego pakietu.

Istnieje odpowiadaj±ca komenda ``no'', która de-importuje rzeczy zaimportowane przez use, np. wywo³uje metodê unimport Module LISTA zamiast import.

    no integer;

    no strict 'refs';

Je¶li nie ma metody unimport, wywo³anie to koñczy siê b³êdem krytycznym.

Dla listy standardowych modu³ów i pragm, zobacz podrêcznik perlmod.

utime LISTA

Zmienia czasy dostêpu i modyfikacji na ka¿dym pliku z listy. Pierwsze dwa elementy listy musz± byæ numerycznymi czasami dostêpu i modyfikacji, dok³adnie w tej kolejno¶ci. Zwraca liczbê plików, na których operacja siê powiod³a. Czas modyfikacji inode jest ustawiany na czas bie¿±cy. Przyk³ad komendy ``touch'':

    #!/usr/bin/perl

    $now = time;

    utime $now, $now, @ARGV;

values HASH

Zwraca normaln± tablicê, sk³adaj±c± siê ze wszystkich warto¶ci wymienionej tablicy asocjacyjnej. W kontek¶cie skalarnym, zwracana jest liczba warto¶ci. Warto¶ci s± zwracane w do¶æ losowej kolejno¶ci, lecz jest ona ta sama, co zwracana przez funkcje keys() lub each(). Jako efekt uboczny, funkcja resetuje iterator tablicy asocjacyjnej. Zobacz te¿ keys(), each(), i sort().

vec WYRA¯,OFFSET,BITY

Traktuje ³añcuch WYRA¯ jako wektor ca³kowitych integerów i zwraca warto¶æ pola bitowego, wskazanego przez OFFSET. BITY podaj± liczbê bitów, które s± zarezerwowane dla ka¿dego wpisu w wektorze bitowym. Musi to byæ potêga dwójki do 1 do 32. vec mo¿e te¿ byæ przypisany do czego¶--w tym wypadku potrzebne s± nawiasy, aby nadaæ wyra¿eniu w³a¶ciwy priorytet, jak w

    vec($image, $max_x * $x + $y, 8) = 3;

Wektory utworzone przez vec() mog± te¿ byæ obs³ugiwane przez operatory logiczne |, & i ^, które za³o¿±, ¿e bitowa operacja wektorowa jest oczekiwana gdy obydwa operandy s± ³añcuchami.

Aby przekszta³ciæ wektor bitowy na tablicê ³añcuchow± zer i jedynek, u¿yj:

    $bits = unpack("b*", $vector);

    @bits = split(//, unpack("b*", $vector));

Je¶li znasz dok³adn± d³ugo¶æ w bitach, mo¿esz podaæ j± zamiast *.

wait

Czeka, a¿ proces potomny siê nie zakoñczy i zwraca pid zamkniêtego procesu, lub -1, je¶li go nie by³o. Status jest zwracany w $?.

waitpid PID,FLAGI

Czeka, a¿ proces potomny siê zakoñczy i zwraca pid zamkniêtego procesu, lub -1, je¶li nie by³o takiego procesu. Status jest zwracany w $?. Je¶li powiesz

    use POSIX ":sys_wait_h";

    ...

    waitpid(-1,&WNOHANG);

to mo¿esz dokonaæ nieblokuj±cego oczekiwania na dowolny proces. Nieblokuj±ce oczekiwanie jest dostêpne na maszynach, obs³uguj±cych albo wywo³anie waitpid(2), albo wait4(2). Jednak oczekiwanie na konkretny pid z FLAGAMI warto¶ci 0 jest zaimplementowane wszêdzie. (Perl emuluje wywo³anie systemowe, pamiêtaj±c warto¶ci statusu procesów, które zakoñczy³y siê, lecz nie by³y odczytane przez skrypt perla)

wantarray

Zwraca TRUE, je¶li kontekst obecnie wykonywanej podprocedury szuka warto¶ci listowej. Zwraca FALSE, je¶li kontekst szuka skalara. Zwraca warto¶æ niezdefiniowan±, je¶li kontekst nie szuka warto¶ci (void).

    return unless defined wantarray;    # nie my¶l o robieniu wiêcej

    my @a = complex_calculation();

    return wantarray ? @a : "@a";

warn LIST

Produkuje komunikat na STDERR, podobnie jak die(), lecz nie wychodzi i nie wyrzuca wyj±tku.

Je¶li zainstalowany jest handler $SIG{__WARN__), nie s± drukowane ¿adne komunikaty. Od handlera zale¿y obs³uga komunikatu, gdy tak zadecyduje (np. przekonwertowanie go na die()). Wiêkszo¶æ handlerów musi wiêc wywo³ywaæ warn() ponownie, aby wy¶wietliæ komunikat. Zauwa¿, ¿e jest to bezpieczne i nie spowoduje nieskoñczonej pêtli, gdy¿ haki __WARN__ nie s± wo³ane z niego samego.

Zachowanie to jest trochê inne od tego dla $SIG{__DIE__} (które nie powstrzymywa³y tekstu komunikatów, lecz mog³y wywo³aæ die() ponownie, aby je zmieniæ).

U¿ywanie handlerów __WARN__ daje potê¿ne narzêdzie do wyciszania wszystkich ostrze¿eñ (nawet tak zwanych obowi±zkowych). Na przyk³ad:

    # wywal wszystkie ostrze¿enia czasu kompilacji

    BEGIN { $SIG{'__WARN__'} = sub { warn $_[0] if $DOWARN } }

    my $foo = 10;

    my $foo = 20;          # bez ostrzegania o zduplikowaniu my $foo

                           # lecz przecie¿ sam siê o to prosi³e¶!

    # bez ostrze¿eñ czasu kompilacji i czasu dzia³ania przed tym miejscem

    $DOWARN = 1;

    # ostrze¿enia czasu dzia³ania s± tu w³±czone

    warn "\$foo is alive and $foo!";     # pojawia siê

Zobacz stronê perlvar(1) dla szczegó³ów o ustawianiu wpisów %SIG i dla przyk³adów.

write UCHWYTPLIKU

write WYRA¯

write

Zapisuje sformatowany rekord (prawdopodobnie wieloliniowy) do podanego pliku, u¿ywaj±c formatu zwi±zanego z tym plikiem. Domy¶lnie format dla pliku jest tym, który ma tê sam± nazwê, co uchwyt pliku, lecz mo¿na go zmieniæ z pomoc± funkcji select(), przypisuj±c nazwê formatu zmiennej $~.

Pocz±tek przetwarzania formy jest obs³ugiwany automatycznie: je¶li nie ma miejsca na stronie na sformatowany rekord, to strona jest przewijana przez wpisanie form feed, nastêpnie u¿ywany jest specjalny format góry-strony (do formatowania nag³ówka nowej strony), a potem wpisany jest rekord. Domy¶lnie, format góry-strony jest nazw± uchwytu pliku z dodanym ``_TOP'', lecz mo¿na go ustawiæ dynamicznie, przyznaj±c zmiennej $^ nazwê podczas gdy wybrany (select) jest uchwyt pliku. Liczba pozostaj±cych linii bie¿±cej strony znajduje siê w zmiennej $- i mo¿e byæ ustawiona na 0 aby wymusiæ now± stronê.

Je¶li UCHWYTPLIKU nie jest podany, wyj¶cie idzie do bie¿±cego domy¶lnego kana³u wyj¶cia, którym jest pocz±tkowo STDOUT, a który mo¿e byæ zmieniony operatorem select. Je¶li UCHWYTPLIKU jest wyra¿eniem WYRA¯, to jest ono analizowane, a wynikowy ³añcuch jest u¿ywany do podejrzenia nazwy UCHWYTUPLIKU. Dla dalszych informacji o formatach, zobacz stronê perlform(1).

Zauwa¿, ¿e zapis NIE jest odwrotno¶ci± odczytu. Niestety.

y///

Operator translacji. To samo co tr///. Zobacz stronê perlop(1).