Provided by: manpages-pl_20051117-1_all bug

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:
       WYGLDA 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 OGLNA REGUA 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ę 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 czyci 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 `ACUCH`
               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).