Weblabor - A kiindulopont webmestereknek
Leírások+Referenciák / Perl röviden / Beépített függvények

A függvények, amelyek ebben a fejezetben le vannak írva kifejezésekben használhatók. Két fõ kategóriába lehet õket sorolni: vannak lista operátorok és unáris operátorok. A lényegi különbség ezek között abban van, hogy míg egy unáris operátor pontosan egy argumentumot dolgoz fel, és így az argumentuma véget ér legkésõbb a következõ vesszõnél, addig a lista operátorok esetében a vesszõ csupán az argumentumokat választja el.

Az unáris operátorok általában skalár környezetet nyújtanak az argumentumuknak, míg a lista operátorok skalár vagy lista környezetet nyújtanak. Ha mind a kettõt nyújtanak, akkor a skalár argumentumok mindig megelõzik a lista argumentumot, mivel mindig csak egy lista argumentum lehet. Például a splice függvény három skalár és egy lista argumentummal dolgozik.

A következõ szintaxis leírásban azok a helyek, ahol a lista operátorok lista környezetet nyújtanak az argumentumaik számára LIST kulcsszóval lesznek jelölve. Az ilyen listák tartalmazhatnak skalár argumentumokat vesszõkkel elválasztva, és listákat, amelyeket a Perl egyszerûen befûz a listába minden egyes elemükkel, egyre hosszabb listát elõállítva. A LIST minden eleme vesszõvel van elválasztva.

Bármelyik függvény, amelyet itt felsorolunk használható az argumentumait bezáró zárójellel, vagy anélkül. (A szintakszis leírásban nem használunk zárójeleket.) Ha használunk zárójeleket, akkor a nagyon egyszerû szabály szerint: ha függvénynek látszik, akkor függvény és a precedencia nem számít. Egyéb esetekben unáris, vagy lista operátor és az operátor precedenciák számítanak. A közök (szóköz, tab, újsor) a függvény neve és a paraméterek körüli nyitózárójel között nem számít, ezért néha igencsak érdemes óvatosnak lenni:

print 1+2+3;        # eredmény 6.
print(1+2) + 3;     # eredmény 3.
print (1+2)+3;      # szintén 3!
print +(1+2)+3;     # eredmény 6.
print ((1+2)+3);    # eredmény 6.

és a kimenet:

63366

Ha a Perl értelmezõt a -w opcióval futtatod, akkor ezekre a dolgokra figyelmeztet.

Azon függvények esetében, amelyek skalár és lista környezetben is használhatóak ha olyan hiba történik, amelyik miatt a program futásának nem kell megszakadnia nem definiált érték undef illetve nulla hosszúságú lista a visszatérési érték.

A következõ szabály örökérvényû:

NINCS ÁLTALÁNOS SZABÁLY A LISTÁK SKALÁRRA VALÓ KONVERZIÓJÁRA!

Minden egyes operátor és függvény, amelyik listát szeretne visszaadni, de skalár környezetben lett meghívva maga dönt arról, hogy melyik konverziós lehetõség a legmegfelelõbb. Néhány operátor annak a listának a hosszát adja vissza, amelyiket lista környezetben adott volna vissza. Más operátorok a lista elsõ elemét adják eredményül. Megint más operátorok a lista utolsó elemét adják vissza. Ismét mások a sikeresen végrehajtott mûveletek számát adják. Általánosságban azt az értéket adják vissza, amelyikre általában a leginkább szükséged van, kivéve ha egyformaságra van szükséged.

Perl függvények kategória szerint

Itt vannak a Perl függvények kategória szerint, és néhány olyan dolog is, amelyik nem függvény, de annak látszik, mint néhány Perl kulcsszó és operátor. Néhány függvény több helyen is elõfordul.

Függvények skalárok és füzérek kezelésére
chomp, chop, chr, crypt, hex, index, lc, lcfirst, length, oct, ord, pack, q/STRING/, qq/STRING/, reverse, rindex, sprintf, substr, tr///, uc, ucfirst, y///

Reguláris kifejezések és mintaillesztés
m//, pos, quotemeta, s///, split, study

Numerikus függvények
abs, atan2, cos, exp, hex, int, log, oct, rand, sin, sqrt, srand

Függvények igazi @TÖMB-ökhöz
pop, push, shift, splice, unshift

Függvények listákhoz
grep, join, map, qw/STRING/, reverse, sort, unpack

Függvények igazi %HASH-ekhez
delete, each, exists, keys, values

Input és output függvények
binmode, close, closedir, dbmclose, dbmopen, die, eof, fileno, flock, format, getc, print, printf, read, readdir, rewinddir, seek, seekdir, select, syscall, sysread, syswrite, tell, telldir, truncate, warn, write

Függvények fix hosszúságú adat rekordokhoz
pack, read, syscall, sysread, syswrite, unpack, vec

Függvények fájl kezelõkhöz (handle) és könyvtárakhoz
-X , chdir, chmod, chown, chroot, fcntl, glob, ioctl, link, lstat, mkdir, open, opendir, readlink, rename, rmdir, stat, symlink, umask, unlink, utime

Kulcsszavak, és programvezérlés
caller, continue, die, do, dump, eval, exit, goto, last, next, redo, return, sub, wantarray

Kulcsszavak
caller, import, local, my, package, use

Vegyes függvények
defined, dump, eval, formline, local, my, reset, scalar, undef, wantarray

Processzekhez és processz csoportokhoz
alarm, exec, fork, getpgrp, getppid, getpriority, kill, pipe, qx/STRING/, setpgrp, setpriority, sleep, system, times, wait, waitpid

Perl modul kulcsszavak
do, import, no, package, require, use

Osztályok és objektum orientált kulcsszavak
bless, dbmclose, dbmopen, package, ref, tie, tied, untie, use

Alacsonyszintû socket függvények
accept, bind, connect, getpeername, getsockname, getsockopt, listen, recv, send, setsockopt, shutdown, socket, socketpair

System V processzek közötti kommunikációs függvények
msgctl, msgget, msgrcv, msgsnd, semctl, semget, semop, shmctl, shmget, shmread, shmwrite

Felhasználói és csoport információs függvények
endgrent, endhostent, endnetent, endpwent, getgrent, getgrgid, getgrnam, getlogin, getpwent, getpwnam, getpwuid, setgrent, setpwent

Hálózati információs függvények
endprotoent, endservent, gethostbyaddr, gethostbyname, gethostent, getnetbyaddr, getnetbyname, getnetent, getprotobyname, getprotobynumber, getprotoent, getservbyname, getservbyport, getservent, sethostent, setnetent, setprotoent, setservent

Idõhöz kapcsolódó függvények
gmtime, localtime, time, times

A Perl5-ben új függvények
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 a Perl4 változatában kulcsszó volt, de a Perl5-ben operátor, amely kifejezésekben használható.

Perl5-ben aktualitásukat vesztett függvények
dbmclose, dbmopen

A Perl függvények ABC sorrendben

-X FILEHANDLE

-X EXPRESSION

-X
Általában fájl teszt, amelyben az X valamelyik betû az alábbi felsorolásból. Ez az unáris operátor egy argumentumot fogad (ezért unáris) amelyik egy fájlkezelõ vagy a fájl neve, és megnézi, hogy a betûhöz rendelt állítás igaz-e. Ha az argumentum hiányzik, akkor automatikusan a $_ változót veszi figyelembe a program kivéve a -t esetet, amelyik ilyen esetben a szabványos bemenetre STDIN vonatkozik. Amennyiben más nincs definiálva az operátor az 1 értéket adja vissza igaz esetben, a '' értéket hamis esetben és undef értéket ha a fájl nem létezik. A furcsa név ellenére ugyanazok a precedencia szabályok vonatkoznak erre az oprátorra, mint bármely más unáris operátorra, és az argumentumok ugyann úgy zárójelezhetõek. Az operátorok listája:

-r

a fájl olvasható az aktuális felhasználó által. (effective uid,gid)

-w

a fájl írható az aktuális felhasználó által. (effective uid,gid)

-x

a fájl végrehajtható az aktuális felhasználó által. (effective uid,gid)

-o

a fájl az aktuális felhasználó tulajdona. (effective uid,gid)

-R

a fájl olvasható a valódi felhasználó által. (real uid,gid).

-W

a fájl írható az aktuális felhasználó által. (real uid,gid).

-X

a fájl végrehajtható az aktuális felhasználó által (real uid,gid).

-O

a fájl az aktuális felhasználó tulajdona. (real uid,gid)

-e

a fájl létezik

-z

a fájl nulla hosszú

-s

a fájl nem nulla hosszú. Visszatérési érték a bájtok száma.

-f

a fájl egyszerû fájl.

-d

a fájl könyvtár

-l

a fájl szimbólikus link.

-p

a fájl egy megnevezett csatorna

-S

a fájl egy socket.

-b

a fájl block special fájl.

-c

a fájl karakter speciális fájl.

-t

a fájlkezelõ egy tty-hoz (terminál) nyitott

-u

a fájl setuid bitje be val állítva

-g

a fájl setgid bitje be van állítva

-k

a fájl sticky bitje be van állítva

-T

a fájl szöveges fájl.

-B

a fájl bináris (-T ellentéte).

-M

a fájl kora napokban a Perl script indulásakor.

-A

ugyanez, de a legutolsó hozzáférési idõt figyelembe véve

-C

ugyanez de inode változási idõre

A fájlhozzáférési operátorok, mint a -r, -R, -w, -W, -x és -X kizárólag csak a hozzáférési engedélyeket vizsgálják, ezen kívül még igen sok oka lehet annak, ha a program nem tudja például írni az egyik fájlt (például betelt a diszk). Ugyanakkor a superuser számára a -r, -R, -w és -W mindig 1-et ad vissza értékként, -x és -X 1-et ad vissza értékként ha bármelyik végrehajtási bit be van billentve. Így azok a programok, amelyeket a superuser futtat a stat függvényt kell, hogy használják, hogy a fájlok valódi módját megkapják, vagy a felhasználói azonosítót (uid) kell erre az idõre átállítani.

Példa:

    while (<>) {
        chop;
        next unless -f $_;      # ignore specials
        ...
    }

Megjegyzendõ, hogy -s/a/b/ nem egy string csere mínusz egyszerese, hanem fájl méretre való hivatkozás, osztva a-val és b-vel. Ugyanakkor -exp $foo úgy mûködik, ahogy várjuk, mert csak az egybetûs operátorokat kezeli a Perl fájl tesztként.

A -T és -B kapcsolók a következõképpen mûködnek. A fájl elsõ blokkját vizsgálja meg a rendszer, és keres bûvös kontrol kódokat, illetve olyan karaktereket, amelyeknek a legfelsõ bitje 1. Ha több mint 30% ilyen karaktert talál, akkor a fájl -B különben -T. Bármilyen fájl, amelyik nulla értékû karaktert tartalmaz az elsõ blokkban bináris fájl. Ha ezen kapcsolókat fájlkezelõkre alkalmazzuk, akkor a beolvasott puffert vizsgálja meg a rendszer az elsõ blokk helyett. Mind a két kapcsoló igaz értéket ad vissza nulla fájlon, illetve ha olyan fájlkezelõvel hívják meg, amely EOF-on áll.

Mivel a -T és -B opciókhoz a fájl olvasása szükséges, azért érdemes a fájlt elõször a -f operátorral megvizsgálni, mint a next unless -f $file && -T $file.

Ha bármelyik fájl vizsgálat, beleértve a stat és lstat operátorokat is fájlkezelõ, vagy fájlnév helyett magában álló aláhúzás karaktert kap argumentumként, akkor az utolsó megvizsgált fájlra adja az eredményt. Ezzel egy rendszerhívást megspórol a rendszer. (Kivéve a -t kapcsolót, és az is megjegyzendõ, hogy a lstat és -l a szimólikus link és nem a valódi fájl adatait hagyja a stat struktúrában. Például:

    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 VALUE
Az argumentum abszolút értékét adja vissza.

accept NEWSOCKET,GENERICSOCKET
Elfogad egy bejövõ socket kapcsolatot, ahogy az accept(2) rendszerhívás teszi. A packet címet adja vissza siker esetén, FALSE értéket egyébként.

alarm SECONDS
Gondoskodik róla, hogy a paraméterként megadott számú másodperc múlva egy alarmot kapjon a processz. (Néhány gépen egy másodperccel hamarabb.) Egyszerre csak egy számláló mûködhet. Minden egyes hívás a korábbi hívások hatását törli, és ha 0 argumentummal hívjuk meg a függvényt, akkor minden egyes korábbi hívás hatását törli újabb alarm elõjegyzése nélkül. A visszatérési érték az elõzõ alarmig tartó idõ.

Ennél nagyobb pontosságú idõállításhoz a Perl syscall felületét lehet használni a setitimer(2) rendszerfüggvényhez, ha a rendszer ezt támogatja, vagy a select függvényt. Nem ajánlott az alarm és sleep hívások keverése.

atan2 Y,X
Y/X arcus tangense -PI és PI között.

bind SOCKET,NAME
Hozzáköt egy hálózati címet egy sockethez, mint ahogy azt a bind rendszerhívás teszi. TRUE értéket ad vissza siker esetén és FALSE értéket hiba esetén. A NAME egy a socketnek megfelelõ packet cím kell, hogy legyen.

binmode FILEHANDLE
A fájlt íráshoz és olvasáshoz bináris módba állítja minden olyan operációs rendszeren amelyik különbséget tesz bináris és szöveges fájlok között. A szöveges fájloknál a bemeneten a CR LF karakterek LF karakterekké konvertálódnak, és a kimeneten fordítva. binmode nincs hatással semmire UNIX alatt, de DOS, Windows, Windows95, WindowsNT és más modern operációs rendszereken kötelezõ használni, ellenkezõ esetben igen érdekes eredményeket adhat a rendszer.

Gyakorlatilag a UNIX kivételével minden rendszeren szükséges ennek a függvénynek a megfelelõ használata.

Ha FILEHANDLE egy kifejezés, akkor ennek az értékét használja a rendszer, mint a fájlkezelõ nevét.

bless REF,CLASSNAME

bless REF
Ez a függvény megmondja a hivatkozott objektumnak (REF), hogy a CLASSNAME csomaghoz tartozik, illetve az aktuális csomaghoz, ha CLASSNAME nincs megadva. A kényelem kedvéért a visszatérési érték az objektumhoz valóü referencia, mivel a bless meghívása gyakran egy objektum összeállítás utolsó lépése.

Mindig a kétargumentumos változatot használd, ha olyan konstruktor eljárást írsz, amelyik örökölhetõ.

caller EXPRESSION

caller
Az aktuális szubrutinhívás környezetét adja vissza. Skalár környezetben TRUE értéket ad vissza, ha van hívó, azaz ha szubrutinban vagyunk, vagy eval vagy require környezetben, FALSE értéket egyébként. Lista környezetben a visszatérési érték
($package, $filename, $line) = caller;

Ha EXPRESSION is meg van adva, akkor néhány olyan extra információt is visszaad, amelyet a debugger használ. EXPRESSION értéke mondja meg, hogy hány hívási keretet menjen vissza az aktuálishoz viszonyítva.

($package, $filename, $line,
     $subroutine, $hasargs, $wantargs) = caller($i);

Amikor a DB csomagon belül kerül meghívásra még további részletes információ is kiértékelõdik, nevezetesen a @DB::args listába bekerül a szubrutin argumentumainak a listája.

chdir EXPRESSION
Megváltoztatja a munkakönyvtárat EXPRESSION-re, ha lehetséges. Ha EXPRESSION hiányzik, akkor a home könyvtárba megy. A visszatérési értéke TRUE siker esetén, egyébként FALSE. Egy példa olvasható a die függvény magyarázatánál.

chmod LIST
A hozzáférési engedélyeket változtatja meg fájlok listájára. A lista elsõ eleme numerikus kód kell, hogy legyen, amely általában oktális. A visszatérési érték azon fájloknak a száma, ahol sikeres volt az érték beállítás.
$cnt = chmod 0755, 'foo', 'bar';
chmod 0755, @executables;

chomp VARIABLE

chomp LIST

chomp
Ez valamelyest biztonságosabb változata a chop függvénynek. Leveszi a sorvégzõdést, amely megfelel a $/ változóértékének. (Ez a változó $INPUT_RECORD_SEPARATOR néven is ismert az English modullal.) A levett karakterek számát adja meg. Igen gyakran használható abban az esetben, mikor a sorok végérõl kell leszedni az újsor karaktert, de félsz attól, hogy az utolsó sor esetleg nincs újsor karakterrel lezárva. Ha változó nincs megadva, akkor $_ végérõl veszi le az újsor karaktert. Ha paraméterként lista van megadva, akkor a lista minden egyes elemére hajtja végre a sorvégjel eltávolítást.
open(F,"<input.txt");
@q = <>;
close F;
chomp @q;

A chomp függvény bármire használható, ami balérték, így akár egy értékadásra is.

chomp($cwd = `pwd`);
chomp($answer = <STDIN>);

chop VARIABLE

chop LIST

chop
Levágja a paraméterként megadott füzér utolsó karakterét, és visszaadja visszatérési értékként. Elsõdleges felhasználása a sor végérõl az újsor karakter leszedése, de sokkal hatékonyabb, mint a s/\n// mert se nem nézi végig, se nem másolja át a füzért. Ha a változó hiányzik, akkor $_ változót használja.
while (<>) {
    chop;   # avoid \n on last field
    @array = split(/:/);
    ...
}

Mindenre alkalmazható a függvény, ami balérték, így értékadáshoz is.

chop($cwd = `pwd`);
chop($answer = <STDIN>);

Ha argumentumként lista van megadva, akkor a lista minden egyes elemére alkalmazza az utolsó karakter levágást, de csak a legutolsó levágott karaktert adja vissza.

A chop a füzér utolsó karakterét adja vissza. A többi karakter visszaadása, azaz minden karakter kivéve az utolsót a substr($string, 0, -1) függvénnyel lehetséges.

chown LIST
Kicseréli a fájlok tulajdonosát és csoportját. A LIST elsõ két eleme a NUMERIKUS uid és gid ebben a sorrendben. A további elemek a fájlok nevei. A visszaadott érték a sikeresen végrehajtott mûveletek száma.

A legtöbb rendszeren ez a parancs csak superuser jogosultsággal hajtható végre, de elképzelhetõ, hogy mások számára is engedélyezett a parancs végrehajtása olyan esetben, amikor a fájl tulajdonosa csak a csoporthoz tartozást akarja kicserélni valamely másodlagos csoportra.

chr NUMBER
Visszatérési értéke az a karakter, amelynek a numerikus kódját paraméterként megadtuk. Például chr(65) értéke ``A'' ASCII kódtábla esetén.

chroot FILENAME
Ez a függvény úgy mûködik, mint a UNIX rendszerhívás: a paraméterként megadott könyvtár lesz minden további ``/'' jellel kezdõdõ fájlhivatkozás számára a gyökérkönyvtár a pillanatnyi és a gyerek processzek számára. (Az aktuális könyvtár eközben nem változik.) Biztonsági okokból ez a függvény csak a superuser számára elérhetõ. Ha a FILENAME nincs megadva, akkor $_-t használja a rendszer.

close FILEHANDLE
Bezárja a csövet, fagy fájlt, amelyhez a fájlkezelõ (handle) rendelve van. A visszatérési érték TRUE, ha a bezárás sikeres volt, a pufferek ki lettek ürítve, és fájlleíró le lett zárva. Nincs szükség a fájl lezárására, ha azt rögtön követi egy ugyanarra a fájlkezelõre hivatkozó open, mivel az open lezárja a fájlt.

Annyi különbség van, hogy az explicit módon végrehajtott fájl lezárás lenullázza a sorszámlálót $., míg az open által végrehajtott implicit lezárás nem.

Hasonlóan, ha egy csõhöz rendelt fájlkezelõt explicit módon lezár a program, akkor a várni fog a processz lefutására, és a $? változó értékét is beállítja a processz befejezési értékére.

open(OUTPUT, '|sort >foo'); # csõ a sort programhoz
...                         # nyomtatás a csõbe
close OUTPUT;               # megvárja amíg a rendezés befejezõdik
open(INPUT, 'foo');         # elkezdjük beolvasni az eredményt

(Persze ennél van hatékonyabb rendezési lehetõség is.)

A FILEHANDLE lehet egy kifejezés is, amelyik a fájlkezelõ nevét adja meg.

closedir DIRHANDLE
Bezár egy könyvtárat, amelyet a opendir-rel nyitottunk meg.

connect SOCKET,NAME
Megpróbál kapcsolódni egy távoli socket-hez, éppen úgy, ahogy a connect rendszerhívás teszi. Visszatérési értéke TRUE ha sikeres volt, és FALSE egyébként. A NAME egy csomag cím kell, hogy legyen amelyik a socket-nek megfelel.

continue BLOCK
Ez igazából nem egy függvény, hanem egy programvezérlési kulcsszó. Ha egy BLOCK-hoz csatlakozik egy continue BLOCK, akkor ez mindig végrehajtódik, mielõtt a feltételt kiértékelné a program. Így ebbe a BLOCK-ba lehet elhelyezni azokat a programrészleteket, amelyeket akkor is végre kell hajtani, ha a ciklust a next utasítás indítja újra.

cos EXPRESSION
A kifejezés radiánban értelmezett érékéhez rendelt koszinusz értéket adja vissza. Ha a kifejezés hiányzik, akkor a $_ értékét használja.

crypt PLAINTEXT,SALT
Kódolja a PLAINTEXT füzért, pontosan úgy, ahogy a crypt C függvény feltéve, hogy a rendszeren implementálták a függvényt, és nem vették ki, mint potenciális muníciót.

Ez a függvény használható a password fájl ellenõrzésére, például azért, hogy a rendszergazda ellenõrizze, hogy a felhasználók kellõen bonyolult jelszót választottak.

Egy kódrészlet, amelyik ellenõrzi, hogy aki a kódot futtatja tudja a saját UNIX jelszavát:

$pwd = (getpwuid($<))[1];
$salt = substr($pwd, 0, 2);
system "stty -echo";
print "Password: ";
chop($word = <STDIN>);
print "\n";
system "stty echo";
if (crypt($word, $salt) ne $pwd) {
    die "Sorry...\n";
} else {
    print "ok\n";
} 


Természetesen a kulcsszavunkat megadni ismeretleneknek rettentõ butaság, még akkor is ha ez az ismeretlen csupán egy program.

dbmclose ASSOC_ARRAY
[Ez a függvény elavult, ehelyett a tie függvény használandó.]

Megszünteti a kapcsolatot a DBM fájl és a hozzá rendelt tördelõtábla között.

dbmopen ASSOC,DBNAME,MODE
[Ez a függvény elavult, helyette a tie használandó.]

Ez a függvény hozzárendeli egy dbm(3), ndbm(3), sdbm(3), gdbm(), vagy Berkeley DB fájlt egy tördelõtáblához. ASSOC a tördelõtábla neve. Ellentétben a szokásos open függvénnyel az elsõ argumentum nem fájl kezelõ, hanem asszociatív tömb, vagy másnéven tördelõtábla. A második argumentum a fájl neve kiterjesztés nélkül. Ha a fájl nem létezik, akkor a program létrehozza a fájlt a harmadik paraméterként megadott hozzáférési MODE beállításával. (Ez az umask függvénnyel állítható.)

Ha a rendszer csak a régebbi fajta DBM függvényeket támogatja, akkor egy program csak egy dbmopen utasítást hajthat végre. A Perl régebbi verzióiban, ha a rendszeren nem volt sem DBM sem pedig ndbm, a dbmopen hívása hibát generált. Jelenleg ebben az esetben sdbm(3) kerül használatra.

Ha a DBM fájlhoz csak hozzáférési joga van a programnak, akkor csak olvasni fogja tudni a tördelõtábla egyes elemeit, de értéket nem adhat nekik. Ha tesztelni akarod, hogy tudod-e írni a fájlt, akkor használhatók a fájl tesztek, illetve meg lehet próbálni értéket adni a tábla egy elemének egy eval blokkon belül, amely megfogja a hibát.

Megjegyzendõ, hogy az olyan függvények, mint a keys vagy values igen nagy tömböket adhatnak vissza amikor nagyméretû DBM fájlhoz rendelt tördelõtáblára alkalmazzák õket. Ehelyett inkább a each függvényt kell használni.

# print out history file offsets
dbmopen(%HIST,'/usr/lib/news/history',0666);
while (($key,$val) = each %HIST) {
    print $key, ' = ', unpack('L',$val), "\n";
}
dbmclose(%HIST);

defined EXPRESSION
Egy logikai értéket ad vissza annak megfelelõen, hogy a kifejezésnek van-e "igazi" értéke vagy nem. Sok operátor és függvény hiba esetén a undef, azaz nem definiált értéket adja vissza valamilyen hiba esetén. Ez a függvény lehetõvé teszi például azt, hogy különbséget tegyünk a nulla karaktert tartalmazó és a nem definiált füzér között. A függvény használható arra is, hogy tömbök, vagy szubrutinok létét ellenõrizzük.

A tördelõtáblák esetén ellenõrizhetõ, hogy a tördelõ tábla megfelelõ eleme definiált-e. Elõfordulhat, hogy a tördelõtábla eleme létezik, de értéke undef ezért annak ellenõrzése, hogy a tördelõtábla eleme létezik-e precízebben vizsgálható a exists függvénnyel.

    print if defined $switch{'D'};
    print "$val\n" while defined($val = pop(@ary));
    die "Can't readlink $sym: $!"
        unless defined($value = readlink $sym);
    eval '@foo = ()' if defined(@foo);
    die "No XYZ package defined" unless defined %_XYZ;
    sub foo { defined &$bar ? &$bar(@_) : die "No bar"; }

Az undef függvény tartozik ehhez a témához.

Megjegyzés:

Sokan használják a defined függvényt feleslegesen. Például a

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

esetében a hasonlítás sikeres, és $1 értéke definiált, annak ellenére, hogy az értéke semmi, azaz nulla hosszúságú füzér. Pontosan fogalmazva, nem az az igaz, hogy $1 semminek sem felel meg a hasonlításban, hanem az, hogy $1 a semminek felel meg.

delete EXPRESSION
Törli a megadott értéket egy tördelõ táblából. A visszatérési érték a törölt érték, vagy undef ha semmit nem törölt a rendszer. A %ENV tördelõtáblából való törlés módosítja a környezetet. Olyan tördelõtáblából való törlés, amely valamilyen DBM fájlhoz van kötve törli az elemet a tördelõtáblából. (Ugyanakkor a törlés valamilyen tie tördelõtáblából nem feltétlenül ad vissza valamilyen értéket.)

A következõ programrészlet az %ARRAY tördelõtábla összes elemét törli:

foreach $key (keys %ARRAY) {
    delete $ARRAY{$key};
}

(Bár gyorsabb lenne az undef használata.)

Az EXPRESSION kifejezés értéke bármi lehet feltéve, hogy az utolsó mûvelet efy tördelõtábla indexelés, például:

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


die EXPRESSION
Egy eval-on kívül kiírja a EXPRESSION tartalmát a STDERR-re (hibakimenet, általában a képernyõ), és a program kilép $! hibakóddal. Ha $! értéke nulla, akkor processz kiszállási érték ($? >> 8). Ha ez az érték is nulla, akkor a kiszállási érték 255.

eval kiértékelésen belül a die hatására az eval blokk nem értékelõdik ki tovább, az értéke undef és az üzenet a $@ változóba kerül. Ezzel lehetõség nyílik arra, hogy die függvény kivételt okozzon.

Egyenrangú példák:

die "Can't cd to spool: $!\n" unless chdir '/usr/spool/news';
chdir '/usr/spool/news' or die "Can't cd to spool: $!\n" 


Ha az EXPRESSION kifejezés végén nincs újsor karakter, akkor a program aktuális sorszámlálója és a bemeneti rekord számláló is hozzáadódik füzérhez.

Lásd még az exit és warn függvényeket.

do BLOCK
Nem teljesen függvény. Végrehajtódik a BLOCK és a visszatérési érték a BOCK utolsó végrehajtott utasításának értéke. Ha egy ciklusmódosító van a végén, akkor olyan ciklust lehet létrehozni, amelyet legalább egyszer végrehajt a program.

do SUBROUTINE(LIST)
Ez régi, és nem használandó formája a szubrutinhívásnak.

do EXPRESSION
Az EXPRESSION kifejezés értékét, mint fájlnevet értelmezi, és a fájl tartalmát, mint Perl scriptet végrehajtja. Az elsõdleges felhasználási terület szubrutinok beemelése a Perl könyvtárakból.

A következõ két példa egyenértékû:

do 'stat.pl';

és

eval `cat stat.pl`;


kivéve, hogy az elsõ megoldás hatékonyabb, érthetõbb, kevésbé rendszerfüggõ, figyelembe veszi az aktuális program fájlnevet a hibajelzések számára, és végigkeresi az összes -I könyvtárak a fájl megtalálásához, ha a fájl nem található meg az aktuális könyvtárban. Abban viszont teljes egészében megegyezik a két megoldás, hogy mind a kettõ minden egyes alkalommal beolvassa, és a Perl interpreter értelmezi a parancsokat valahányszor az utasítás végrehajtódik, így feltehetõleg nem akarod majd végrehajtani egy ciklus belsejében.

A könyvtári függvények beemelésére sokkal jobb módszer a use és require operátorok használata.

dump LABEL
Ez az utasítás egy azonnali dump-ot hajt végre, azaz megállítja a processzt, és egy olyan bináris fájlt hoz létre, amelyik tartalmazza a processz egész memóriaterületének tartalmát. Ennek az lehet az értelme, hogy UNIX rendszereken az undump programmal ebbõl a fájlból végrehajtható bináris állományt lehet létrehozni, amelyet elindítva a program a dump utasítás utáni LABEL által meghatározott utasítással folytatódik. Ilyenkor a program elsõ utasítása a goto LABEL minden olyan megkötéssel, amely vonatkozik a goto-ra általában. Úgy lehet elképzelni az egészet, mint egy olyan goto utasítást, amely végrehajtása közben a program meghal és azután feltámad. Minden olyan változó, amelyet a program beállított megõrzi az értékét, ugyanakkor azok a fájlok, amelyek meg voltak nyitva nem lesznek megnyitva a program újraindulásakor, és ez megzavarhatja a Perl rendszert is.

Példa:

#!/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 ASSOC_ARRAY
Lista környezetben meghívva egy kételemû listát ad vissza, amely a tördelõtábla következõ kulcsát, és a kulcshoz rendelt értéket adja vissza, így végig lehet menni a tábla összes elemén. Skaláris környezetben meghívva csak a következõ elem kulcsát adja vissza. Az egyes elemek sorrendje nem meghatározott, és nagyban függ attól, hogy az adott Perl implementáció milyen sorrendben tárolja az egyes elemeket. Amikor már nincsen több elem nulla listát ad vissza a függvény lista környezetben, és undef értéket skaláris környezetben. Ezután a következõ each hívás újra az elsõ elemtõl kezdi az iterációt. Az iteráció újraindítása csak úgy lehetséges, ha minden egyes elemen végigmegyünk. Az iteráció közben nem szabad a tördelõtáblához elemeket hozzáadni. Minden tördelõtáblához csak egy iteráló változó tartozik, és ezt használja mind a each, mind a keys, mind pedig a values függvény. A következõ programdarab a környezeti változókat írja ki:
while (($key,$value) = each %ENV) {
   print "$key=$value\n";
}



Nézd még meg a keys és values függvényeket.

eof FILEHANDLE

eof ()

eof
1-et ad visszatérési értékként ha a következõ FILEHANDLE-ra vonatkozó olvasás fájlvégéhez érne, vagy ha nincs a FILEHANDLE fájlkezelõhöz nyitott fájl. FILEHANDLE lehet egy kifejezés, amely ebben az esetben a fájlkezelõ nevét adja meg.

Megjegyzendõ, hogy ez a függvény egy karaktert olvas a fájlból, majd az ungetc C függvénnyel visszarakja az értéket. Az eof használata terminál fájlon, vagy az abból való olvasás hatására a terminál féjl elvesztheti a fájlvégjelet.

Ha nem adunk meg argumentumot az eof függvénynek, akkor azt a fájlkezelõt használja amelyet legutoljára használt olvasási utasítás. Az üres zárójelek () használata azokra a peszeudo fájlokra vonatkozik, amelyeket a parancssorban adtunk meg, így az eof() használható egy while(<>) ciklusban az utolsó fájl végének ellenõrzésére. A eof(ARGV)-t kell használni ha minden egyes fájl végét tesztelni akarjuk. Példák:

# lenullázza a sorszámozást minden új fájl elõtt
while (<>) {
   print "$.\t$_";
   close(ARGV) if (eof);   # Nem eof()
}



és

# mínuszjeleket szúr be az utolsó fájl utolsó sora elé
while (<>) {
    if (eof()) {
        print "--------------\n";
        close(ARGV);        # close vagy break; szükséges, ha a
                            # terminálrólolvasunk
    }
    print;
}



Gyakorlatilag soha nincs szükség Perl-ben az eof használatára, mert a beolvasó függvények visszatérési értéke undef ha kifutnak a beolvasható értékekbõl.

eval EXPRESSION

eval BLOCK
EXPRESSION értelmezésre és végrehajtásra kerül, úgy, mintha egy kis Perl program lenne. A végrehajtás abban a környezetben történik, amelyben a pillanatnyi futás van, így minden szubrutin definíció, változóérték használható. A visszatérési érték az utolsó végrehajtott utasítás értéke, vagy a return utasítás értéke, amely éppúgy használható, mint a szubrutinok esetében.

Ha szintaktikus hiba van a programrészletben, futási hiba történik, vagy egy die utasítást hajt végre a program, akkor undef értéket ad vissza a függvény és $@ tartalmazza a hibaüzenetet. Ha nem történthiba, akkor $@ garantáltan nulla hosszúságú füzér. Ha az argumentumként megadott EXPRESSION nincs megadva, akkor a függvény $_-t használja. Az utolsó pontosvesszõ hiányozhat a kifejezésbõl.

Mivel a eval függvény elfogja az egyébként végzetes hibákat, még a szintaktikus hibákat is, ezért az eval függvény használható annak ellenõrzésére, hogy egyes rendszerfüggõ eljárások mûködnek-e egy adott környezetben. Így például ellenõrizhetõ, hogy a socket vagy symlink függvények implementáltak-e. Az eval használható arra is, hogy a die függvénnyel kivételeket lehessen megvalósítani.

Ha a kód az egyes végrehajtások között nem változik, akkor az eval BLOCK használható arra, hogy az egyes hibákat megfogja a rendszer anélkül, hogy minden egyes végrehajtáshoz a Perl újrafordítaná a kódrészletet. A hibaüzenet, ha van, ebben az esetben is $@ változóba kerül. Példák:

# nullával való osztásután tovább fut a program
eval { $answer = $a / $b; }; warn $@ if $@;
# ugyanaz, de kevésbé hatékony
eval '$answer = $a / $b'; warn $@ if $@;
# ez fordítás ideji hibát generál
eval { $answer = };
# ez viszont futási idõben csak $@ értékét állítja be
eval '$answer =';   # sets $@

Az eval használatánál különösen oda kell figyelni arra, hogy mit is hajt végre a Perl futtató. Például

eval $x;            # 1. ESET
eval "$x";          # 2. ESET
eval '$x';          # 3. ESET
eval { $x };        # 4. ESET
eval "\$$x++"       # 5. ESET
$$x++;              # 6. ESET


Az elsõ két változat egyenértékû, mind a kettõ az $x változóban levõ füzért hajtja végre, mint Perl programrészletet, annak ellenére, hogy az idézõjelek a második esetben egy kicsit félrevezetõk, és a program olvasója egy kicsit megakad elgondolkodva azon, hogy vajon még mi történik itt az idézõjelek miatt (semmi). A harmadik és negyedik eset hasonló módon azonos, a végrehajtott kód $x, ami végsõ soron nem csinál semmit. Az ötödik eset az, amikor az idézõjelek használatának igazából értelme van, kivéve azt, hogy ebben az esetben szimbolikus referenciát is lehet használni.

exec LIST
Az exec rendszerfüggvény végrehajt egy rendszerparancsot, és nem tér vissza. Ha egy rendszerparancsot úgy akarunk meghívni, hogy utána a program visszatér, akkor a system függvényt kell használni.

Ha több, mint egy argumentuma van a függvénynek, vagy, ha az argumentum egy tömb, amelynek több, mint egy eleme van, akkor a rendszer az execvp(3) rendszerhívást hajtja végre, a LIST argumentumokkal. Ha csak egy skalár argumentuma van a függvénynek, akkor ezt a rendszer shell metakarakterek szempontjából ellenõrzi. Ha van ebben shell metakarakter, akkor az egész argumentumot átadja a rendszer a /bin/sh -c paranccsal a rendszernek. Ha nincsenek metakarakterek, akkor az argumentum szavakra lesz bontva, és az így keletkezett szó lista kerül direkt módon az execvp() rendszerhívásba.

Sem az exec, sem pedig a system függvények nem söprik ki a kimeneti puffereket, ezért érdemes $| változót beállítani, hogy ne vesszen el kimenet.

Példák:

exec '/bin/echo', 'Your arguments are: ', @ARGV;
exec "sort $outfile | uniq";

Ha hazudni akarsz a végrehajtandó programnak a nevét illetõen, akkor a lista elé indirekt objektumként, vesszõ nélkül lehet beírni a végrehajtandó parancsot. Ebben az esetben az argumentumokat minden esetben listaként értelmezi a Perl, még abban az esetben is, ha csak egy skalár érték szerepel a listában.

Példák:

$sh = '/bin/csh';
exec $sh '-sh'; # nézzen ki úgy, mint egy login shell

vagy direktebb módon:

exec {'/bin/csh'} '-sh'; # nézzen ki úgy, mint egy login shell

exists EXPRESSION
Visszatérési értéke TRUE, ha a megadott tördelõtábla elem létezik, még abban az esetben is, ha annak értéke undef.

Példa:

print "Exists\n" if exists $array{$key};
print "Defined\n" if defined $array{$key};
print "True\n" if $array{$key};

Egy elem lehet TRUE, ha definiált, és definiált, ha létezik, de a fordított állítás nem feltétlenül igaz.

A kifejezés tetszõlegesen bonyolult lehet, feltéve, hogy az utolsó mûvelet egy tördelõtábla keresés, például

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

exit EXPRESSION
Kiértékeli az EXPRESSION kifejezést, és ennek értékével kilép a programból. Ha definiálva van bármilyen END függvény, akkor ezeket hívja elõször, de ezek nem tudják az exit függvényt megállítani. Hasonlóan az objektum lebontók, amelyeket meg kell hívni meghívódnak a kifejezés kiértékelése elõtt. Ha az EXPRESSION hiányzik, akkor a kilépési érték nulla.

Példa:

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

Hasonló függvény: die.

exp EXPRESSION
Kiszámítja az eEXPRESSION értéket, ahol e a természetes logaritmus alapszáma. Ha EXPRESSION nincs megadva, akkor az exp($_) értéket számítja ki.

fcntl FILEHANDLE,FUNCTION,SCALAR
A UNIX rendszerek fcntl függvényét valósítja meg. Feltehetõleg ennek használatához a use Fcntl; parancsot kell használnod a korrekt függvénydefiníciók eléréséhez.

Az argumentumok kezelése éppen úgy történik, mint a ioctl függvénynél. Az fcntl minden olyan gépen, amelyen nincsen implementálva a fcntl rendszerfüggvény fatális hibát generál.

Példa:

use Fcntl;
fcntl($filehandle, F_GETLK, $packed_return_buffer);

fileno FILEHANDLE
Visszaadja a fájl leírót egy fájl kezelõhöz. Ez akkor lehet különösen kellemes amikor bittérképet kell készíteni a select függvényhez. Ha a FILEHANDLE egy kifejezés, akkor ennek értéke adja meg a fájlkezelõ nevét.

flock FILEHANDLE,OPERATION
Meghívja a flock rendszerfüggvényt a FILEHANDLE által kezelt fájlra. A rendszerdokumentáció flock(2)manuál oldalán olvasható, hogy OPERATION pontosan milyen értékek esetén mit csinál. Az olyan rendszereken, ahol sem az flock sem pedig az fcntl nincs implementálva fatális hibát generál (például Windows95). Ha egy rendszeren az flock nincs implementálva, de az fcntl igen, akkor automatikusan ezt hívja meg a Perl program. Ezzel az flock hordozható fájl lezárási módszer, de egész fájlokat lehet csak lezárni vele, nem rekordokat.

Egyes rendszereken az flock nem mûködik hálózaton keresztüli fájlokra, ilyenkor a sokkal rendszerfüggõbb fcntl használandó.

Egy egyszerû példa, amely egy BSD rendszerben a mailbox-hoz fûz hozzá:

$LOCK_SH = 1;
$LOCK_EX = 2;
$LOCK_NB = 4;
$LOCK_UN = 8;
sub lock {
    flock(MBOX,$LOCK_EX);
    # és ha esetleg valaki írt a fájl végéhez
    # amíg vártunk...
    seek(MBOX, 0, 2);
 }
sub unlock {
    flock(MBOX,$LOCK_UN);
 }

open(MBOX, ``>>/usr/spool/mail/<STRONG>$ENV</STRONG>{'USER'}'')
      or die ``Can't open mailbox: $!'';
lock();
print MBOX $msg,"\n\n";
unlock();

fork
Végrehajt egy fork(2) rendszerhívást. A gyerek pid (processz azonosító) a visszatérési értéke az apa processzben, és 0 a gyerek processzben, vagy undef ha a fork sikertelen. A kitakarítatlan pufferek azok maradnak mind a két processzben, így $| értékének beállítása vagy az autoflush meghívása szükséges a dupla mûveletek elkerülése érdekében.

Ha a fork függvényt úgy hívod meg, hogy nem vársz a gyermek processzre, akkor zombikat generálsz:

$SIG{CHLD} = sub { wait };

Egy mási dupla fork trükk:

unless ($pid = fork) {
    unless (fork) {
        exec "amit csak végre akarunk hajtani";
        die "nincs exec";
        # ... vagy ...
        ## (Perl kód jön ide)
        exit 0;
    }
    exit 0;
}
waitpid($pid,0);

format
Deklarál egy nyomtatási képformátumot, amelyet azután a write függvény használ. Például:
format Something = 
    Test: @<<<<<<<< @||||| @>>>>>
          $str,     $%,    '$' . int($num)
.
$str = "widget";
$num = $cost/$quantity;
$~ = 'Something';
write;


formline PICTURE, LIST
Ez egy belsõ függvény, amelyet a format hív meg, de amelyet meghívhat a Perl program is. Egy sor értéket formáz meg a PICTURE formátumnak megfelelõen, és az eredményt a format kimenet gyûjtõbe $^ helyezi el.

Tulajdonképpen amikor egy write függvényhívás történik a $^ tartalma íródik ki egy fájlba.

getc FILEHANDLE

getc
Visszaadja a következõ karaktert a FILEHANDLE fájlkezelõhöz rendelt fájlból, vagy nulla füzért ad vissza a fájl végén. Ha nincs megadva fájlkezelõ, akkor a szabványos bemenetrõl olvas. Ez a függvény nem túl hatékony, és ugyanakkor nem használható nem pufferelt egyedi karakterek beolvasására sem. Ehhez valami ilyesmire van inkább szükség:
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";


getlogin
Az aktuális login értéket adja vissza az /etc/utmp fájlból. Ha nulla, akkor a getpwuid függvényt kell használni,
$login = getlogin || (getpwuid($<))[0] || "Verhas";

Ugyanakkor a getlogin függvény nem ajánlott autentikációs feladatokhoz, mert nem elegendõen biztonságos.

getpeername SOCKET
Visszaadja a csomag sockaddr címét a SOCKET kapcsolat másik végének.
use Socket;
$hersockaddr    = getpeername(SOCK);
($port, $iaddr) = unpack_sockaddr_in($hersockaddr);
$herhostname    = gethostbyaddr($iaddr, AF_INET);
$herstraddr     = inet_ntoa($iaddr);

getpgrp PID
Visszaadja a pillanatnyi processz csoportot a megadott PID-hez. Ha a PID nulla, vagy nincs megadva akkor a program processzhez adja meg a csoportot. Hibát generál olyan gépeken, ahol a getpgrp(2) rendszerhívás nincs implementálva. A POSIX verziója a getpgrp() függvénynek csak az aktuális processzhez mondja meg a csoportot, ezért a getpgrp használata csak PID==0 esetén hordozható.

getppid
Az apa processz azonosítóját adja vissza.

getpriority WHICH,WHO
Az aktuális processz, processz csoport vagy felhasználó prioritását adja vissza. Fatális hibát okoz olyan gépeken, ahol a getpriority rendszerhívás nincs implementálva.

getpwnam NAME

getgrnam NAME

gethostbyname NAME

getnetbyname NAME

getprotobyname NAME

getpwuid UID

getgrgid GID

getservbyname NAME,PROTO

gethostbyaddr ADDR,ADDRTYPE

getnetbyaddr ADDR,ADDRTYPE

getprotobynumber NUMBER

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
Ezek a függvények pont azt teszik, mint a megfelelõik a rendszerkönyvtárban. Lista környezetben a visszatérési értékek csoportonként különböznek a következõk szerint:
($name,$passwd,$uid,$gid,
   $quota,$comment,$gcos,$dir,$shell) = getpw*
($name,$passwd,$gid,$members) = getgr*
($name,$aliases,$addrtype,$length,@addrs) = gethost*
($name,$aliases,$addrtype,$net) = getnet*
($name,$aliases,$proto) = getproto*
($name,$aliases,$port,$proto) = getserv*

Ha a megfelelõ elem nem létezik, akkor nulla listát ad vissza a rendszer.

Skalár környezetben a nevet adja vissza a rendszer, kivéve, ha függvény éppenséggel név szerinti keresésre irányul. Ekkor éppen a másik dolgot adja vissza a függvény, bármi legyen is az a másik dolog.

Ha a megfelelõ elem nem létezik, akkor undef értéket ad vissza a rendszer. Például:

$uid = getpwnam
$name = getpwuid
$name = getpwent
$gid = getgrnam
$name = getgrgid
$name = getgrent
stb.

A $members érték amit a getgr* függvények visszadnak a csoporthoz tartozó felhasználók login neveit adják meg egy füzérben szóközzel elválasztva.

A gethost*() függvények, amennyiben a C rendszer támogatja a h_errno változót ennek értékét a $? változóban adják vissza. A @addrs változó, amelyet a sikeres hívás ad vissza a nyers címeket tartalmazzák, amelyeket a a megfelelõ rendszerfüggvény adott vissza. Az Internet tartományban minden ilyen cím négy bájt hosszú és kicsomagolható egy

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

paranccsal.

getsockname SOCKET
A távolis Socket kapcsolat csomag sockaddr címét adja vissza.
use Socket;
$mysockaddr = getsockname(SOCK);
($port, $myaddr) = unpack_sockaddr_in($mysockaddr);

getsockopt SOCKET,LEVEL,OPTNAME
Visszaadja a kért socket opciókat, és undef ha valamilyen hiba történt.

glob EXPRESSION
Visszaadja a fájl nevét a megfelelõ joker karakter kiegészítéssel, úgy ahogy azt a shell tenné. Ez a belõ függvény, amelyet a <*.*> operátor használ.

gmtime EXPRESSION
Átkonvertálja az argumentumként megadott idõt (amelyet a time függvénybõl nyerünk) egy kilenc elemû listává. Ez az idõ nem lesz lokalizálva, azaz a greenwichi középidõt adják meg a tömb egyes elemei. A tipikus felhasználás:
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
                                            gmtime(time);

Az összes listaelem numerikus, és direkt módon a struct tm rekordból kerülnek ki. Másszavakkal ez azt jelenti, hogy $mon nulla és 11 között lesz, $wday nulla és 6 között.

Ha nincs EXPRESSION megadva, akkor gmtime(time()) kerül kiszámításra.

goto LABEL

goto EXPRESSION

goto &NAME
A goto LABEL forma megkeresi azt az utasítást, amely a LABEL címkével van megjelölve, és ennél az utasításnál folytatja a futást. Nem használható bármilyen olyan programstruktúrába való beugrásba, amely valamilyen inicializálást kíván, mint szubrutin, vagy foreach hurok. Akkor sem szabad ilyen struktúrába belelépni ezzel az utasítással, ha azt a Perl értelmezõ kioptimalizálta.

Gyakorlatilag bárhova el lehet ugrani a dinamikus kereteken belül, akár ciklusból vagy szubrutinból ki is. Ugyanakkor ezekre alkalmasabb valamely más konstrukció, például last vagy die.

A goto EXPRESSION azt várja, hogy a kifejezés értéke egy cimke legyen, amelyet a kifejezés kiértékelése után megkeres a Perl értelmezõ, és onnan folytatja a futást. Ez olyan kiszámított goto lehetõséget ad, mint amilyent egyesek FORTRAN-ban szokhattak meg, de nem ajánlott a használata.

A gotot &NAME forma meghívja a NAME szubrutint, de amikor az visszatér akkor nem a goto utasítás után folytatódik a futás, hanem ott ahol ahonnan a goto-t tartalmazó szubrutint meghívták. Más szavakkal ez a goto olyan, mint egy szubrutinhívás, amelyet rögtön követ egy return utasítás, azzal a különbséggel, hogy a hívott szubrutin ebben az esetben más vermet, és más hívótlát (caller).

Ezt az utasítást általában a modulok AUTOLOAD szubrutinjai használják, amelyek futási idõben, akkor töltenek be egyes szubrutinokat, amikor azokra a hivatkozás történik, majd úgy hívja meg azokat, mintha rögtön azokat hívta volna meg a program (kivéve, hogy minden módosítás, amely a @_ változón történik a hívott félnél megmarad). A goto után a még a caller függvény sem tudja megmondani, hogy nem ez a szubrutin volt elsõként meghívva.

grep BLOCK LIST

grep EXPRESSION,LIST
Végrehajtja a BLOCK vagy EXPRESSION blokkot, illetve kifejezést a LIST lista minden elemére (helyileg beállítva $_ értékét az egyes elemekre és visszaad egy olyan listát, amely tartalmazza azokat az elemeket, amelyekre a BLOCK vagy EXPRESSION értéke TRUE. Skaláris környezetben azt adja meg, hogy hányszor volt a kifejezés értéke TRUE.
@foo = grep(!/^#/, @bar);    # kitöröljük a megjegyzéseket
       # ekvivalens módon
@foo = grep {!/^#/} @bar;    # ugyanezt csinálja

Mivel $_ referenciaként kerül beállításra, ezért használható arra, hogy a lista egyes elemeit módosítsa a grep függvény, de ez igen bizarr eredményeket adhat abban az esetben, amikor a LIST lista nem egy névvel hivatkozott tömb.

hex EXPRESSION
Az EXPRESSION kifejezést, mint hexadecimálisan megadott füzért értelmezi, és a numerikus értéket adja vissza. Az olyan számok értelmezésére, amelyek vagy 0x karakterekkel kezdõdnek az oct függvény használható.

Ha EXPRESSION nincs megadva, akkor $_ értékét használja a függvény.

import
Nincs igazi, beépített import függvény. Sokkal inkább ilyen néven kell definiálni egy modulon belül azt a szubrutint amelyek a szimbólumtábla importját végzik. Ez az a szubrutin, amelyet a use függvény hív meg.

index STR,SUBSTR,POSITION

index STR,SUBSTR
Visszaadja a SUBSTR füzér STR füzérbeli elsõ elõfordulási helyének az indexét a POSITION pozíciónál, vagy az után. Ha nincs megadva pozíció, akkor a füzér elejétõl kezdi a keresést. A visszatérési érték nullától indul (illetve attól az értéktõl amire $[ be lett állítva, de jobb ilyet nem tenni), másképp fogalmazva az elsõ karakter indexe nulla, a másodiké egy stb.

Ha a füzér nem található meg, akkor visszatérési érték -1, pontosabban fogalmazva $[-1.

int EXPRESSION
Az EXPRESSION kifejezés egészrészét adja vissza. Ha nincs megadva argumentum, akkor $_ egészrészét adja vissza.

ioctl FILEHANDLE,FUNCTION,SCALAR
Az ioctl(2) rendszerfüggvényt valósítja meg. Ennek használata elõtt feltehetõleg a
    require "ioctl.ph"; # probably in /usr/local/lib/perl/ioctl.ph

sorral be kell emelni a függvény definícióját. Ha ez a fájl nem létezik az adott rendszeren, akkor nem marad más, mint a megfelelõ C fejléc fájlok alapján elõállítani, de ez nem triviális.

SCALAR értékét fogja a függvény írni, illetve olvasni a FUNCTION függvénynek megfelelõen. Ha SCALAR füzér, akkor a rendszerfüggvény a füzérre mutató mutatót ad át, míg ha értéke numerikus, akkor magát a numerikus értéket. Hogy biztos legyen, hog egy érték numerikus elõtte adjunk hozzá nullát.

A pack és unpack függvények nagyon hasznosak lehetnek az ioctl függvény által kezelt struktúrák manipulálásához.

A következõ példa a DEL karaktert állítja törlõ karakterré:

require 'ioctl.ph';
$getp = &TIOCGETP;
die "NO TIOCGETP" if $@ || !$getp;
$sgttyb_t = "ccccs";                # 4 chars and a short
if (ioctl(STDIN,$getp,$sgttyb)) {
    @ary = unpack($sgttyb_t,$sgttyb);
    $ary[2] = 127;
    $sgttyb = pack($sgttyb_t,@ary);
    ioctl(STDIN,&TIOCSETP,$sgttyb)
        || die "Can't ioctl: $!";
}

Az ioctl és fcntl függvények visszatérési értéke a következõ:

     az operációs rendszer             a Perl
      visszatérési értéke        visszatérési értéke

            -1                        undef
             0                  füzér "0 de TRUE"
        bármi más szám               maga a szám

Így a Perl függvény visszatérési értéke TRUE siker esetén, és FALSE hiba esetén, mégis lehetõség van megnézni, hogy az operációs rendszer milyen értéket adott vissza.

($retval = ioctl(...)) || ($retval = -1);
printf "System returned %d\n", $retval;

join EXPRESSION,LIST
A LIST listában szereplõ füzéreket fûzi össze egy füzérré az EXPRESSION kifejezés által megadott füzérrel, mint elválasztóval. Például:
print join('|' , (1,2,3,5,6,7,9,"kurtavas"));

kimenete

1|2|3|5|6|7|9|kurtavas

Az ellentétes hatású függvény, amely egy füzért szétbont listává a split.

keys ASSOC_ARRAY
A visszatérési értéke egy tömb, amely tartalmazza az argumentumként megadott tördelõtábla kulcsait. Skaláris környezetben a kulcsok számát adja meg. A sorrend, ahogy a kulcsok szerepelnek a tömbben nem rendezett, de garantáltan ugyanaz a sorrend, ahogy az egyes elemeket a values illetve az each adja vissza, feltéve, hogy két ilyen függvényhívás között nem változott meg a tördelõtábla.

Egy újabb példa a környezeti változók kiírására:

@keys = keys %ENV;
@values = values %ENV;
while ($#keys >= 0) {
    print pop(@keys), '=', pop(@values), "\n";
}


és a környezeti változók azon a gépen, ahol e dokumentum HTML-re fordítása történt:

SYSTEMDRIVE=E:
PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.JS
OS2LIBPATH=E:\WINNT4\system32\os2\dll;
PROCESSOR_LEVEL=5
LIB=D:\Program Files\Mts\Lib
USERDOMAIN=DECINT
LOGONSERVER=\\CELEBRIS
HOMEPATH=\
TEMP=E:\TEMP
TMP=E:\TEMP
COMPUTERNAME=CELEBRIS
USERPROFILE=E:\WINNT4\Profiles\verhas
NUMBER_OF_PROCESSORS=1
PROCESSOR_REVISION=0205
PATH=C:\Perl5\bin;E:\WINNT4\system32
WINDIR=E:\WINNT4
COMSPEC=E:\WINNT4\system32\cmd.exe
SYSTEMROOT=E:\WINNT4
INCLUDE=D:\Program Files\Mts\Include
HOMEDRIVE=E:
OS=Windows_NT
PROCESSOR_ARCHITECTURE=x86
PROCESSOR_IDENTIFIER=x86 Family 5 Model 2 Stepping 5, GenuineIntel
PROMPT=$P$G
USERNAME=verhas

kill LIST
Jelzést (signal) küld a LIST listában szereplõ processzeknek. A LIST lista elsõ eleme a jelzés értéke, a további elemek a processz azonosítók. A visszatérési érték a sikeres jelküldések száma.
$cnt = kill 1, $child1, $child2;
kill 9, @goners;


A shell-lel ellentétben, Perl-ben ha a jel értéke negatív, akkor processz csoportoknak küldi a kill a jelet. (A System V rendszereken is így van, az azonban nem hordozható, Perl-ben minden rendszeren így van, ahol a kill függvény implementált.) Ez azt jelenti, hogy általában pozitív értékeket kell használni. Használhatók a jelek nevei aposztrófok között is.

last LABEL

last
A last nem függvény, hanem egy utasítás. A hatása hasonló a C programozási nyelvbeli break utasításhoz. Hatására a program azonnal abbahagyja a ciklus végrehajtását. Ha a LABEL címke nincs megadva, akkor a legbelsõ ciklus futását szakítja meg a program, ha LABEL meg van adva, akkor azt a ciklust szakítja meg, amelyre a címke vonatkozik.

A program futása a parancs végrehajtásának hatására a ciklus utáni utasításon folytatódik. continue blokk nem hajtódik végre.

$i = 7;
CIKLI:
 while(1){
   $j = 1;
   while(1){
     last if $j == 3 && $i < 9 ;
     last CIKLI if $j == 3;
     print $i,$j++ ;
     }
   $i++;
   }


és a kimenete:

717281829192

lc EXPRESSION
Az EXPRESSION kifejezés, mint füzér kisbetûs alakját adja vissza. Ez az a belsõ függvény, amelyet a \L escape szekvencia használ. Elvileg figyelembe kell vennie minden POSIX setlocale() beállítást.

lcfirst EXPRESSION
Az EXPRESSION kifejezés, mint füzért adja vissza, úgy, hogy az elsõ karakter kisbetûs. Ez az a belsõ függvény, amelyet a \l escape szekvencia használ. Elvileg figyelembe kell vennie minden POSIX setlocale() beállítást.

length EXPRESSION
Az EXPRESSION kifejezés, mint füzér karakterekben mért hosszát adja vissza. Ha az EXPRESSION nincs megadva, akkor $_-t használja.

link OLDFILE,NEWFILE
Létrehoz egy új fájlnevet NEWFILE néven, amelyet a régi fájlhoz OLDFILE kapcsol. A visszatérési értéke 1 siker esetén, és 0 egyébként. Windows NT alatt nincs implementálva.

listen SOCKET,QUEUESIZE
Ugyanazt teszi, mint az azonos nevû rendszerhívás. Visszatérési értéke TRUE siker esetén, és FALSE egyébként.

local LIST
A local nem egy függvény, hanem egy Perl utasítás, amely a LIST listában felsorolt változókat teszi lokálissá egy szubrutin, eval vagy do blokk erejéig. Ez a lokalitás azonban nem olyan, mint amit PASCAL, C vagy bármilyen más programozási nyelvben megszokhattunk.

A local által adott lokalitás futási idejû, és nem grammatikai. A grammatikai lokalitást a my utasítás adja.

Részletes leírás található a szbrutinokról szóló fejezetben.

localtime EXPRESSION
Átkonvertálja az argumentumként megadott idõt (amelyet a time függvénybõl nyerünk) egy kilencelemû listává. A megadott idõ helyi idõ lesz. A tipikus felhasználás:
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
                                            localtime(time);

Az összes listaelem numerikus, és direkt módon a struct tm rekordból kerülnek ki. Másszavakkal ez azt jelenti, hogy $mon nulla és 11 között lesz, $wday nulla és 6 között.

Ha nincs EXPRESSION megadva, akkor gmtime(time()) kerül kiszámításra.

Skalár környezetben füzérként írja ki az idõt a ctime(3) rendszerhívásnak megfelelõen.

$a =localtime;
print $a;

Mon Jul  6 09:57:29 1998

log EXPRESSION
Az argumentumként megadott EXPRESSION kifejezés természetes alapú logaritmusát számítja ki és adja vissza értékként. Ha EXPRESSION kifejezés nincs megadva, akkor $_-t használja a program.

lstat FILEHANDLE

lstat EXPRESSION
Ugyanazt teszi, mint a stat függvény, de nem a fájl paramétereit vizsgálja meg, hanem a szimbolikus link-ét. Ha a szimbolikus linkek nincsenek implementálva a rendszeren, akkor ugyanaz a hatása, mint a stat-nak.

m//
A mintaillesztési operátor. Részletesen a reguláris kifejezések fejezetben.

map BLOCK LIST

map EXPRESSION,LIST
Kiértékeli a BLOCK blokkot, vagy az EXPRESSION kifejezést a LIST lista minden egyes elemére, úgy, hogy közben $_ tartalmazza az éppen aktuális listaelemet. A visszatérési érték egy lista, amely az egyes kiértékelések eredményeibõl adódik. A kiértékelés minden egyes ciklusban listakörnyezetben zajlik, így egy-egy kiértékelés több, mint egy listaelemet is eredményezhet, a végsõ lista ezeknek az összefûzésébõl fog adódni.
@chars = map(chr, @nums);

számok listáját konvertálja a megfelelõ karakterekké.

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

ugyanaz, mint

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

mkdir FILENAME,MODE
Létrehozza a FILENAME könyvtárak a megadott hozzáférési móddal. Ha a mûvelet sikeres a visszatérési érték 1, ha nem akkor 0 és $! tartalmazza a hibaüzenetet.

msgctl ID,CMD,ARG
Meghívja a System V IPC msgctl(2) függvényt. Ha CMD &IPC_STAT, akkor ARG egy változó kell, hogy legyen, amelyik tartalmazza a visszaadott msqid_ds struktúrát. A visszatérési érték az ioctl-hez hasonlóan undef hiba esetén és "0 de TRUE" zero esetén, illetve az aktuális érték egyébként.

msgget KEY,FLAGS
Meghívja a System V IPC msgget(2) függvényt. A visszatérési érték az üzenetsor azonosító, illetve undef hiba esetén.

msgsnd ID,MSG,FLAGS
Meghívja a System V IPC msgsnd függvényt az MSG üzenet elküldésére az ID azonosítójú üzenetsorba. Az MSG üzenetnek egy hosszú egész (long int) számmal kell kezdõdnie, amelyet például a pack('l',$type) függvénnyel lehet létrehozni. A visszatérési érték TRUE siker esetén, és FALSE egyébként.

msgrcv ID,VAR,SIZE,TYPE,FLAGS
Meghívja a System V IPC msgrcv függvényt, hogy az ID azonosítójú üzenetsorból üzenetet kapjon a VAR változóba, maximum SIZE méretben. Amennyiben üzenet érkezik, az elsõ dolog a VAR változóban az üzenet típusa lesz és a VAR változó mérete SIZE plusz az üzenet típus mérete. A visszatérési érték TRUE siker esetén és FALSE egyébként.

my EXPRESSION
A my nem egy függvény, hanem egy Perl utasítás, amely a LIST listában felsorolt változókat teszi lokálissá egy szubrutin, eval vagy do blokk erejéig. Ez a lokalitás olyan, mint amit PASCAL, C vagy bármilyen más programozási nyelvben megszokhattunk ellentétben a local utasítással.

Részletes leírás található a szbrutinokról szóló fejezetben.

next LABEL

next
A next egy olyan ciklusutasítás, amelynek hatására a ciklus újraindul úgy, mint a C programozási nyelvben a continue hatására.

Ha a ciklushoz van continue blokk, akkor az ebben található utasítások végrehajtónak a next hatására, mielõtt a ciklus újraindulna.

Ha nincs megadva LABEL címke, akkor az utasítás a legbelsõ ciklusra vonatkozik.

no Module LIST
A use függvény ellentéte.

oct EXPRESSION
Az EXPRESSION kifejezést, mint oktális füzért értelmezi, és az értékét adja vissza. Ha a füzér éppen 0x karakterekkel kezdõdik, akkor hexadecimális értékként értelmezi. A következõ sor mind a decimális, mind az oktális, mind pedig a hexadecimális számokat megfelelõen konvertálja, amennyiben azok a C szintaxisnak (ami Perl-ben ugyanaz) megfelelnek:
$val = oct($val) if $val =~ /^0/;

Ha EXPRESSION nincs megadva, akkor $_-t használja a rendszer.

open FILEHANDLE,EXPRESSION

open FILEHANDLE
Megnyit egy fájlt, amelynek a nevét az EXPRESSION tartalmazza, és hozzárendeli a FILEHANDLE fájlkezelõhöz. Ha FILEHANDLE helyén egy kifejezés van, akkor ennek az értékét fogja használni, mint a fájlkezelõ nevét. Ha az EXPRESSION kifejezés hiányzik, akkor a skaláris változó, amelynek ugyanaz a neve, mint a FILEHANDLE fájlkezelõnek tartalmazza a fájl nevét. Ha a fájlnév < karakterrel kezdõdik akkor olvasásra nyitja meg a rendszer a fájlt. (Egyébként ez az alapviselkedés, ha tehát a következõk egyikének sem felel meg a szintaxis, akkor is olvasásra nyitja meg a fájlt.)

Ha a fájlnév > karakterrel kezdõdik, akkor írásra nyitja meg. Ha a fájlnév kezdete >> akkor hozzáírásra nyitja meg a fájlt (írásra a végére pozícionálva, így hozzáír a fájlhoz).

Egy + jel kerülhet a < vagy > jel elé a mind írásra, mind pedig olvasásra való megnyitáshoz. Általában a +< a szokásos írás/olvasás megnyitási forma, mivel a +> a fájlt elõször törli. Ezek megfelelnek a fopen(3) rendszerhívás 'r', 'r+', 'w', 'w+', 'a', és 'a+' módjainak.

Ha a fájlnév egy | karakterrel kezdõdik, akkor a fájlnevet a rendszer mint parancsot értelmezi amelynek bemenete a csõ, ha pedig az utolsó karakter, akkor olyan parancsként értelmezi a rendszer amelynek kimenetébõl olvasunk.

Olyan open() parancsot nem lehet kiadni, amelyikbe írunk is és olvasunk is belõle.

- megnyitása a szabványos bemenet megnyitását jelenti, és >- megnyitása a szabványos kimenet.

Siker esetén a függvény visszatérési értéke nem nulla, hiba esetén undef. Ha a fájl történetesen egy csõ, akkor a visszatérési érték az alprocessz PID-je.

Ha olyan rendszeren használod a Perl-t, amelyik különbséget tesz bináris és text fájlok között, akkor érdemes használni a binmode függvényt. A lényegi különbség a text fájlok sorvégjelölésében van.

$ARTICLE = 100;
open ARTICLE or die "Can't find article $ARTICLE: $!\n";
while (<ARTICLE>) {...

open(LOG, '>>/usr/spool/news/twitlog'); # (log is reserved)
open(DBASE, '+<dbase.mine');            # open for update
open(ARTICLE, "caesar <$article |");    # decrypt article
open(EXTRACT, "|sort >/tmp/Tmp$$");     # $$ is our process id

# feldolgozzuk a fájlokat, és minden include fájlt
foreach $file (@ARGV) {
    process($file, 'fh00');
}
sub process {
   local($filename, $input) = @_;
   $input++; #ez füzér növelés!!
   unless (open($input, $filename)) {
     print STDERR "Can't open $filename: $!\n";
     return;
     }
   while (<$input>) {              # note use of indirection
     if (/^#include "(.*)"/) {
     process($1, $input);
     next;
     }
      ...         # bármilyen kód
  }
    }

A Bourne shell hagyományainak megfelelõen ha a fájlnév >& karakterekkel kezdõdik, akkor a füzér további része, mint a fájlkezelõ neve értelmezõdik, és ez lesz megduplázva és megnyitva. Az & karakter használható >, >>, <, +>, +>> és +< után. A módnak ugyanannak kell lenni, mint az eredeti fájlnál.

Itt egy rövid script, amely elmenti, átirányítja, és visszaállítja az STDOUT és STDERR-t:

#!/usr/bin/perl
open(SAVEOUT, ">&STDOUT");
open(SAVEERR, ">&STDERR");
open(STDOUT, ">foo.out") || die "Can't redirect stdout";
open(STDERR, ">&STDOUT") || die "Can't dup stdout";
select(STDERR); $| = 1;     # make unbuffered
select(STDOUT); $| = 1;     # make unbuffered
print STDOUT "stdout 1\n";  # this works for
print STDERR "stderr 1\n";  # subprocesses too
close(STDOUT);
close(STDERR);
open(STDOUT, ">&SAVEOUT");
open(STDERR, ">&SAVEERR");
print STDOUT "stdout 2\n";
print STDERR "stderr 2\n";

Ha a fájlnév <&= karakterekkel kezdõdik, akkor a Perl a C nyelv fdopen függvényének megfelelõen mûködik.

Ha egy csövet (pipe) nyitunk meg a - fájlnévre, akár |- akár pedig -| formában, akkor implicit módon egy fork hajtódik végre. Az open visszatérési értéke ebben az esetben a gyermek processz PID-je az apában és 0 a gyerekben. (Ilyenkor az open értéke helyett a defined függvénnyel kell megvizsgálni, hogy sikeres volt-e a megnyitás.) Az apában a fájlkezelõ normálisan lesz megnyitva, és az írás/olvasás a gyermek processz felé halad/onnan jön. A gyerekben a fájlkezelõ nem lesz megnyitva, az írás és olvasás a szabványos bemeneten és kimeneten kell, hogy történjen.

A close meghívása bármely csõre a gyermek processz végére való várakozást jelenti és a visszatérési érték $? változóba kerül.

Minden olyan operációs esetén, amelyik fork-ot hajt végre, a kiürítetlen pufferek kiürítetlenek maradnak, ezért ezekre a $| értékét 1-re kell állítani.

A FileHandle csomag használatával lehetõség van olyan fájlkezelõ nevek kialakítására, amelyek ugyanolyan környezetben használhatók, mint a rájuk hivatkozó változók, és automatikusan bezárja õket a rendszer, amikor minden hivatkozás megszûnik a fájlra:

use FileHandle;
...
sub read_myfile_munged {
  my $ALL = shift;
  my $handle = new FileHandle;
  open($handle, "myfile") or die "myfile: $!";
  $first = <$handle>
    or return ();     # automatikusan bezárja itt
  mung $first or die "mung failed";       # vagy itt
  return $first, <$handle> if $ALL;       # vagy itt
  $first;                                 # vagy itt
  }

A fájlnévbõl, amelyet az open megkap a bevezetõ és a lezáró szóközöket kitörli. Emiatt, ha olyan fájlt akarsz megnyitni, amely bevezetõ, vagy lezáró szóközöket tartalmaz, ezeket meg kell védeni. Ennek egy lehetséges módja:

$file =~ s#^(\s)#./$1#;
open(FOO, "< $file\0");

Ha igazi C open-t szeretnél, akkor a sysopen függvényt kell használni. Ez egy másik lehetõség a fájlnév teljes megvédésére, például

use FileHandle;
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 "A fájl tartalma: ", <HANDLE>;

Érdemes még a seek függvényt is megtanulni ahhoz, hogy hogyan lehet az olvasást, és az írást keverni.

opendir DIRHANDLE,EXPRESSION
Az EXPRESSION kifejezés által megadott nevû könyvtárat nyitja meg, hogy a readdir, telldir seekdir rewinddir és closedir függvényekkel hozzá lehessen férni a fájlnevekhez. Visszatérési értéke TRUE siker esetén és FALSE egyébként. A DIRHANDLE könyvtárkezelõ külön névterületen van nyilvántartva, elkülönítve a fájlkezelõktõl, így egy könyvtárkezelõnek lehet ugyanaz a neve, mint egy fájlkezelõnek.

ord EXPRESSION
Az EXPRESSION által adott füzér elsõ karakterének ASCII kódját adja vissza. Ha nincs argumentum megadva, akkor $_ értékét veszi.

pack TEMPLATE,LIST
Sorba veszi a LIST lista elemeit, és egy bináris értéket alkot belõlük a TEMPLATE füzérnek megfelelõen értelmezve a LIST lista egyes elemeit. A TEMPLATE-ben az egyes karakterek jelentése:
  • A ASCII füzér szóközökkel kiegészítve.
  • a ASCII füzér nulla karakterekkel kiegészítve.
  • b bit füzér növekvõ bit sorrendben, mint a vec függvénynél.
  • B bit füzér csökkenõ bit sorrendben.
  • h hexadecimális füzér alacsony helyérték elõször.
  • H hexadecimális füzér magas helyérték elõször.
  • c elõjeles karakter érték.
  • C elõjel nélkülikarakter érték.
  • s elõjeles rövid egész.
  • S elõjel nélküli rövid egész.
  • i elõjeles egész.
  • I elõjel nélküli egész.
  • l elõjeles hosszú egész.
  • L elõjel nélklüli hosszú egész.
  • n rövid egész "hálózati" sorrendben.
  • N hosszú egész "hálózati" sorrendben.
  • v rövid egész VAX (little endian) sorrendben.
  • V hosszú egész VAX (little endian) sorrendben.
  • f szimpla pontosságú lebegõpontosságú szám natív formátumban.
  • d dupla pontosságú lebegõpontos szám natív formátumban.
  • p nulla lezárású füzérre mutató mutató.
  • P struktúrára mutató mutató.
  • u uuencode kódolású füzér.
  • w BER kompresszált egész. A bájtok ebben a formában 128-as számrendszerben tartalmazzák a számot, a legnagyobb helyérték az elsõ bájtban, a lehetõ legkevesebb bájton ábrázolva, és a legfelsõ bit minden bájtban nulla, kivéve az utolsó bájtot.
  • x Egy nulla bájt.
  • X Egy bájt visszalépés.
  • @ Nulla kitöltés abszolút pozícióig.

Minden egyes betût követhet egy szám, amely megadja, hányszor kell a betût figyelembe venni. Minden típusnál, kivéve az ``a'', ``A'', ``b'', ``B'', ``h'', ``H'', és ``P'' típusokat a pack függvény ennyi argumentumot dolgoz fel az adott betûre a listából. A * mint ismétlési érték azt jelenti, hogy a lista maradék elemeit mind az adott típus szerint kell feldolgozni. Az ``a'' és ``A'' csak egy értéket vesz a listából, de a megadott szám hosszúságú füzért állít belõle elõ nullákkal kiegészítve ha szükséges. Az unpack függvény használatakor az ``A'' leveszi a lezáró szóközöket és nullákat, de az ``a'' nem. Ennek megfelelõen az ismétlési érték a ``b'' és ``B'' karaktereknél a bitek, a ``h'' és ``H'' karaktereknél a hexa digitek számát adja meg. A ``P'' esetén a szám a struktúra méretét adja meg, amelyre a mutató mutat. A valós számok (float és double) natív formában kerülnek tárolásra, mivel nincsen elfogadott szabvány, amely a hálózaton keresztüli adatcserét lehetõvé tenné. Ez azt jelenti, hogy az egyik gépen összepakolt lebegõpontos számok nem feltétlenül kicsomagolhatók egy másikon, még akkor sem, ha mind a két gép IEEE lebegõpontos formátumot használ, mivel az IEEE formátum nem határozza meg a bájtsorrendet.

A Perl nyelv belül, mint a C mindig duplapontosságú számokat használ, ezért a simapontosságúra való konverzió veszít a precizitásából. Emiatt például

unpack(``f'', pack(``f'', $foo) == $foo

nem feltétlenül igaz.

$foo = pack("cccc",65,66,67,68);
# foo eq "ABCD"
$foo = pack("c4",65,66,67,68);
# ugyanaz
$foo = pack("ccxxcc",65,66,67,68);
# foo eq "AB\0\0CD"
$foo = pack("s2",1,2);
# "\1\0\2\0" little-endian gépen
# "\0\1\0\2" big-endian gépen
$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"

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

Általánosan azt lehet mondani, hogy ugyanazt a TEMPLATE füzért lehet használni az unpack függvényben is.

package NAMESPACE
Egy fordítási egységet definiál az adott névterülethez. A package deklaráció hatásterülete az utasítást tartalmazó blokk végéig tart. Az utasítás után minden változó, amelyhez nincs explicit módon névterület megadva az adott névterülethez fog tartozni.

Tipikusan ez az az utasítás, amely elsõkét szerepel egy olyan fájlban, amelyet egy require vagy use függvénnyel használ valamely Perl program.

Egy ilyen csomagba több helyen is be lehet kapcsolódni, a package utasítás csak annyit mond a fordítónak, hogy mely névterületet használja a fordítás során a blokk végéig.

Más névterületen levõ változókra, vagy fájlkezelõkre explicit névterület megadással lehet hivatkozni, a névterületet a változó neve elé kell írni két kettõsponttal elválasztva: $csomag::változó. Ha a csomag neve nulla, akkor a main csomagot használja a Perl, azaz $::quty ugyanaz, mint $main::quty.

pipe READHANDLE,WRITEHANDLE
Egy csõpárt nyit meg, hasonlóan az ugyanilyennevû rendszerhíváshoz. Perl a csöveknél puffereket használ, ezért szükség lehet $| 1-re állítására a WRITEHANDLE kiürítésére minden egyes parancs után, az alkalmazás igényeinek megfelelõen.

pop ARRAY
Kiveszi egy tömb utiolsó elemét, és visszatérési értékként adja. Ugyanaz a hatása, mint a
    $tmp = $ARRAY[$#ARRAY--];

utasításnak.

Ha a tömbben nincsen egyetlen elem sem, akkor a visszatérési érték undef. Ha nincs argumentum megadva, akkor az @ARGV tömböt használja a fõprogramban, és a @_ tömböt szubrutinokban, éppen úgy, mint a shift.

pos SCALAR
Azt a pozíciót adja meg, ahol a legutolsó m//g keresés megállt a SCALAR változóhoz. Érték is adható ennek a függvénynek, amelynek hatására a következõ keresés annál a karakternél fog folytatódni, amelyet megadtunk.

Példa

#               11111
#     012345678901234
#       |    |   |  |
$s = 'bbb abbbabb bbb';

while( $s =~ m/bb/g ){
  print pos($s),"\n";
  }

amelynek kimenete

2
7
11
14

és

#               111111
#     0123456789012345
#       ||   ||  |  ||
$s = 'bbb abbbabb bbb';

while( $s =~ m/bb/g ){
  print $i=pos($s),"\n";
  pos($s) = --$i;
  }

amelynek kimenete

2
3
7
8
11
14
15

print FILEHANDLE LIST

print LIST

print
A listában szereplõ füzéreket nyomtatja ki. Visszatérési értéke TRU siker esetén. FILEHANDLE lehet egy skalár változó, amely esetben a változó által megadott füzért használja a Perl, mint a fájlkezelõ nevét.

Ha a FILEHANDLE nincs megadva, akkor a szabványos kimenetre nyomtat, illetve a legutoljára select függvénnyel kiválasztott csatornába. Ha a LIST lista is hiányzik, akkor $_ értékét írja ki. Mivel a print egy listát ír ki, ezért bármi, ami a print argumentumai között kiértékelõdik lista környezetben értékelõdik ki.

Oda kell figyelni arra is, hogy ha a listában az elsõ argumentum valamiért nyitózárójellel kezdõdik, akkor ezt a Perl a print függvény argumentumait körülzáró nyitó zárójelnek veszi és a záró zárójel utáni listaelemeket nem nyomtatja ki. Vagy egy + jelet kell a nyitózárójel elé tenni, vagy az összes argumentumot még egy zárójelpárba kell zárni.

Ha a FILEHANDLE neve egy tömb elemeként van megadva, vagy bármilyen más kifejezés értékeként, akkor a kifejezést kapcsos zárójelek közé kell tenni.

print { $files[$i] } "stuff\n";
print { $OK ? STDOUT : STDERR } "stuff\n";


printf FILEHANDLE LIST

printf LIST
Ugyanaz, mint a print FILEHANDLE sprintf(LIST) utasítás. Az elsõ argumentum adja meg a nyomtatási formátumot.

prototype FUNCTION
A függvény prototípusát adja meg, vagy undef értéket, ha a függvénynek nincsen prototípusa.

push ARRAY,LIST
Az ARRAY tömböt, mint egy vermet kezeli, és a LIST lista elemeit hozzáfûzi a tömb végéhez. Ennek megfelelõen megnövekszik a tömb mérete. A visszatérési érték a tömb új mérete. Ugyanaz a hatása, mint a
for $value (LIST) {
  $ARRAY[++$#ARRAY] = $value;
  }


utasításnak, csak sokkal hatékonyabb.

q/STRING/

qq/STRING/

qx/STRING/

qw/STRING/
Általánosított idézõjel. Nem függvény, hanem operátor.

quotemeta EXPRESSION
Az EXPRESSION kifejezés, mint füzér értékét adja vissza úgy, hogy minden reguláris kifejezés meta-karakter \ karakterrel van megelõzve. Ez egy belsõ függvény, amely az idézõjelek között megadott füzérekben a \Q escape szekvenciát valósítja meg.

rand EXPRESSION

rand
Egy véletlen valós számot ad vissza 0 és EXPRESSION között (EXPRESSION értéke pozitív kell, hogy legyen). Ha EXPRESSION nincs megadva, akkor 0 és 1 közötti értéket ad vissza. Ez a függvény minden futáskor ugyanazt a szekvenciát adja vissza, kivéve ha a srand függvényt is használjuk.

Néhány Perl implementációban elõfordulhat, hogy a rand függvény túl nagy, vagy túl kicsi értékeket ad vissza. Ennek oka, hogy a Perl értelmezõ fordításakor rosszul volt beállítva a RANDBITS C konstans. Ilyenkor az EXPRESSION kifejezést lehet az általában megfelelõ kettõ-hatvány értékkel megszorozni, de ezzel a program elveszti a hordozhatóságát. Sokkal jobb megoldás a megfelelõ RANDBITS értékkel újrafordítani a programot.

read FILEHANDLE,SCALAR,LENGTH,OFFSET

read FILEHANDLE,SCALAR,LENGTH
Megpróbál LENGTH bájtnyi adatot a SCALAR változóba olvasni a megadott FILEHANDLE fájlkezelõbõl. A visszatérési érték a valóban beolvasott bájtok száma vagy undef ha hiba történt. SCALAR mérete nõni vagy csökkenni fog annak megfelelõen, hogy mennyi adatot olvas be a read. Ha OFFSET-et megadjuk, akkor ezzel meghatározhatjuk, hogy a SCALAR változóban hányadik bájttól kezdõdõen helyezze el a read függvény a beolvasott bájtokat. Ez a függvény a C stdio könyvtár fread függvényével lett megvalósítva. A valódi rendszerhíváshoz a sysread függvényt kell használni.

readdir DIRHANDLE
Megadja a következõ könyvtári bejegyzést abból a könyvtárból, amelyet az opendir függvénnyel nyitottunk meg. Ha lista környezetben használjuk, akkor a maradék könyvtári bejegyzések listáját adja meg. Ha nincs több bejegyzés akkor undef értéket ad vissza skaláris környezetben, vagy nulla hosszúságú listát lista környezetben.

Ha az így kapott értékeket, mint fájlneveket használod, akkor ne feledd el a megfelelõ könyvtár nevet eléjük illeszteni, vagy egy chdir parancsot kiadni.

opendir(DIR, $some_dir) || die "$some_dir nem nyitható meg: $!";
@dots = grep { /^\./ && -f "$some_dir/$_" } readdir(DIR);
closedir DIR;

readlink EXPRESSION
Visszaadja a szimbolikus link értékét, ha a szimbolikus linkek a rendszeren implementálva vannak. Egyébként fatális hibát ad. Ha rendszerhiba történik a hívás során, akkor a visszatérési érték undef és $! tartalmazza a hibakódot. Ha EXPRESSION nincs megadva, akkor $_-t használja.

recv SOCKET,SCALAR,LEN,FLAGS
Fogad egy üzenetet a socket-en, Megpróbál LENGTH bájtnyi adatot fogadni a SCALAR változóba a SOCKET fájlkezelõ által meghatározott socket-bõl. A visszatérési érték a küldõ címe. Hiba esetén a visszatérési érték undef. SCALAR mérete aszerint nõ vagy csökken, hogy mennyi adatot kell tartalmaznia. FLAGS ugyanazokat az értékeket tartalmazhatja, mint a rendszerhívás.

redo LABEL

redo
The Nem függvény, hanem Perl parancs, amely egy ciklust indít újra. Hatása hasonló a next utasításhoz, de nem értékeli ki ismételten a ciklus feltételt, hanem egyszerûen a ciklus elejére ugrik és a continue blokkot sem hajtja végre. Ha a LABEL nincs megadva, akkor az utasítást bezáró legbelsõ ciklusra vonatkozik.

ref EXPRESSION
Visszatérési értéke TRUE? ha EXPRESSION kifejezés egy referencia (mutató) és FALSE egyébként. Az érték, amelyet visszaad attól függ, hogy mi az az objektum amelyre a referencia vonatkozik. A beépített típusok:
  • REF
  • SCALAR
  • ARRAY
  • HASH
  • CODE
  • GLOB
Ha a hivatkozott objektum egy osztályhoz tartozik (lásd bless), akkor az osztály/csomag nevét adja meg. A ref egy kicsit olyan, mint a C-ben a typeof operátor.
if (ref($r) eq "HASH") {
    print "r is a reference to an associative array.\n";
} 
if (!ref ($r) {
    print "r is not a reference at all.\n";
} 

rename OLDNAME,NEWNAME
Átnevezi a fájlt OLDNAME névrõl NEWNAME névre. Visszatérési értéke 1 siker esetén és 0 egyébként. Nem mûködik fájlrendszerek között.

require EXPRESSION

require
Megkövetel bizonyos szemantikát, amelyet az EXPRESSION kifejezés, vagy ennek hiányában $_ ad meg. Ha EXPRESSION numerikus, akkor azt követeli meg, hogy a futtató Perl verziója $] legalább ilyen vagy késõbbi legyen.

Egyéb esetben azt követeli meg, hogy egy könyvtári fájl betöltõdjön, ha még nem lett betöltve. A fájl betöltése a do függvénnyel kerül betöltésre, amely az eval egy változata. A require szemantikája hasonlít a következõ Perl-ben megírt függvényre:

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 "Can't find $filename in \@INC";
    }
    die $@ if $@;
    die "$filename did not return true value" unless $result;
    $INC{$filename} = $realfilename;
    $result;
}

A fájl nem lesz kétszer betöltve azonos név alatt. A fájnak a kiértékelés során TRUE értéket kell visszaadnia, ez jelzi azt, hogy az inicializáló kód sikeresen futott le, ezért szokás ezeket a fájlokat egy lezáró '1;' utasítással befejezni.

Ha EXPRESSION egy meztelen szó, akkor a require feltételezi, hogy a könyvtári fájl kiterjesztése .pm és a névben a :: jeleket kicseréli / jelekre. Ennél sokkal hatékonyabbés funkcionálisabb könyvtárbetöltési lehetõség a use használata.

reset EXPRESSION

reset
A ?? kereséseket, vagy változókat állít alaphelyzetbe (nullára). Ha nincsen megadva argumentum, akkor a ciklusban a mintaillesztési kereséseket állítja alaphelyzetbe, úgy, hogy azok a ciklus tesztben ismét megtalálják a megfelelõ füzéreket. Ha argumentum van megadva, akkor az argumentum, mint karakterek listája kerül értelmezésre, és minden olyan változó, amelyiknek a neve ezen karakterek valamelyikével kezdõdik lenullázódik. A mínuszjel karakter tartományok megadására megengedett. Csak az aktuális csomagban nullázza le a változókat illetve a kereséseket.

return LIST
Visszatér egy szubrutinból, vagy egy eval utasításból. Ha nem használjuk ezt az utasítást, akkor az eval utasítás, vagy a szubrutin a legutolsó végrehajtott utasítás értékével tér vissza.

reverse LIST
Lista környezetben a lista elemeit adja vissza fordított sorrendben. Skaláris környezetben a lista elsõ elemének a bájtjait adja vissza fordított sorrendben.
@q = (1,2,3,4);
print reverse @q;
print reverse 'alma';
$b = reverse 'alma';
print $b;

és a kimenet (érdemes egy pillanatra elgondolkodni rajta)

4321almaamla

rewinddir DIRHANDLE
Visszaállítrja a könyvtárkezelõt a readdir utasításokhoz a könyvtár elejére.

rindex STR,SUBSTR,POSITION

rindex STR,SUBSTR
Ugyanúgy mûködik, mint az index függvény, de nem az elsõ, hanem a SUBSTR füzér utolsó STR-beli elõfordulási helyét adja meg. Ha POSITION meg van adva, akkor az utolsó elõfordulást, amely az elõtt a pozíció elõtt van, adja meg.

rmdir FILENAME
Törli a könyvtárat, amelyet a FILENAME ad meg, amennyiben az üres. Ha sikeres a törlés a visszatérési érték 1, egyébként 0 és a hibakód $!-ba kerül. Ha FILENAME nincs megadva, akkor $_ tartalmazza a fájl nevét.

s///
Nem függvény, hanem a mintaillesztési és cserélési operátor. Lásd a leírásban.

scalar EXPRESSION
A kifejezést skaláris környezetben értékeli ki, és az így kapott értéket adja vissza.
print        reverse 'alma';
print scalar reverse 'alma';

Nincs ellentétes list operátor, mert általában nincsen rá szükség. Ha valamit lista környezetben kell kiértékelni, az vagy listakörnyezetben van úgyis, vagy használható a @{[ (kifejezés) ]} alak, amely esetén a kifejezés lista környezetben fog kiértékelõdni.

seek FILEHANDLE,POSITION,WHENCE
Pozícionálja a FILEHANDLE fájlkezelõhöz rendelt fájlmutatót, éppen úgy, mint az fseek az stdio könyvtárban. FILEHANDLE lehet egy kifejezés, amelynek az értéke adja a fájlkezelõ nevét. WHENCE értéke lehet
  • 0 a fájlpozíció értéke POSITION lesz
  • 1 a fájlpozíció értéke a mostani pozíció plusz POSITION
  • 2 a fájlpozíció értéke POSITION a fájl végéhez viszonyítva.
Használhatók a POSIX modulból a SEEK_SET, SEEK_CUR és SEEK_END szimbolikus konstansok. Visszatérési értéke 1 siker esetén, és nulla hiba esetén.

Néhány rendszer megköveteli a seek meghívását egy fájlon belüli olvasási és írási mûveletek között. Ilyenkor a

    seek(TEST,0,1);

utasítás használható a fájlmutató helyben hagyásához. Ez arra is jó, hogy ha fájl végére értünk, és egy másik processz írja a fájlt, akkor törli a fájlvége feltételt. Ellenkezõ esetben a Perl egy újabb <FILE> mûveletnél nem próbál meg olvasni a fájlból, akkor sem ha közben valaki írt bele. Ellenben ha a seek függvényt meghívjuk, akkor újra próbálkozik.

Ha ez mégsem mûködne (végül is a Perl rendszer C-ben van megírva, és minden rendszeren a stdio könyvtárat használja, és ez a mûködés ettõl függ) akkor valami ehhez hasonlót kell megpróbálni:

for (;;) {
    for ($curpos = tell(FILE); $_ = <FILE>; $curpos = tell(FILE)) {
        # itt csinálunk valamit és kiírunk a fájlba
    }
    sleep($for_a_while);
    seek(FILE, $curpos, 0);
  }

seekdir DIRHANDLE,POS
Beállítja a readdir számára a könyvtárpozíciót a DIRHANDLE könyvtárkezelõhöz. A POS pozíció egy olyan érték kell, hogy legyen, amelyet a telldir adott vissza értékként.

select FILEHANDLE

select
A pillanatnyilag kiválasztott fájlkezelõt adja vissza értékként, illetve beállítja a az alapértelmezett fájlkezelõt a kiment számára, amennyiben FILEHANDLE argumentumkéntmeg van adva. Ennek két hatása van:
  1. Egy write vagy print függvény ezt a fájlkezelõt fogja használni, ha más fájlkezelõ nincs megadva.
  2. Azok a változók, amelyek a kimeneti fájlra vonatkoznak erre a fájlra fognak vonatkozni, például a $^ vagy $| változók.
A FILEHANDLE lehet egy olyan kifejezés, amelynek értéke, mint füzér adja meg a fájlkezelõ nevét. Így a tipikus használat például a pufferelés kikapcsolására:
$oldfh = select(STDERR); $| = 1; select($oldfh);

select RBITS,WBITS,EBITS,TIMEOUT
Ez a hívás a select(2) rendszerfüggvényt hívja meg a megfelelõ bitmaszkkal, amelyet a fileno és vec függvényekkel lehet elõállítani a következõképpen:
$rin = $win = $ein = '';
vec($rin,fileno(STDIN),1) = 1;
vec($win,fileno(STDOUT),1) = 1;
$ein = $rin | $win;

Ha sok fájlkezelõt egyszerre akarsz kiválasztani, akkor a következõ szubrutin segíthet:

sub fhbits {
    local(@fhlist) = split(' ',$_[0]);
    local($bits);
    for (@fhlist) {
        vec($bits,fileno($_),1) = 1;
    }
    $bits;
}
$rin = fhbits('STDIN TTY SOCK');


A szokásos forma:

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

vagy blokkolni, amíg valami rendelkezésre nem áll

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

A legtöbb rendszer nem ad vissza semmit a $timeleft-ben, ezért a select hívása skaláris környezetben csak $nfound értéket ad vissza.

A bitmaszkok bármelyike lehet undef. Az idõhatár (timeout) ha meg van adva, akkor másodpercben értendõ, de lehet tört érték is. Nem minden implementáció képes a $timeleft kiszámítására. Ebben az esetben ezek a rendszerek a $timeleft változóban a megadott értéket adják vissza.

Egy 250 milli-másodperces várakozást a következõképpen lehet megvalósítani:

    select(undef, undef, undef, 0.25);

FIGYELMEZTETÉS: Ne keverd a pufferelt i/o mûveleteket a select függvény használatával. Ilyenkor a sysread függvényt kell használni.

semctl ID,SEMNUM,CMD,ARG
Meghívja a System V IPC semctl függvényt. Ha CMD &IPC_STAT vagy &GETALL akkor ARG egy változó kell, hogy legyen, amely a visszaadott semid_ds struktúrát fogja tartalmazni vagy a szemafor tömböt. A visszatérési érték olyan, mint ioctl esetében, undef hiba esetén, ``0 de TRUE''zero esetén, illetve a visszatérési érték egyébként.

semget KEY,NSEMS,FLAGS
Meghívja a System V IPC semget függvényt. Visszaadja a szemafort, vagy undef értéket hiba esetén.

semop KEY,OPSTRING
Meghívja a System V IPC semop függvényt a szemafor mûveletekhez, mint jelzés és várakozás. OPSTRING egy csomagolt tömb kell, hogy legyen, amely semop struktúrákat tartalmaz. Minden egyes semop struktúra elõállítható a
pack(``sss'',$semnum, $semop, $semflag)
függvénnyel. A szemafor operációk számát az OPSTRING hossza adja meg. Visszatérési értéke TRUE siker esetén, és FALSE ha hiba történt.

send SOCKET,MSG,FLAGS,TO

send SOCKET,MSG,FLAGS
Üzenetet küld egy socket-re. Ugyanazt a flag-et használja, mint a rendszerhívás. Kapcsolat nélküli socket esetében meg kell határozni a cél TO címet is. Ebben az esetben a C sendto() függvénynek megfelelõ a mûködés. Az elküldött karakterek számát adja meg, vagy undef értéket, ha valamilyen hiba történt.

setpgrp PID,PGRP
Beállítja a processz csoportot a megadott PID-hez, illetve az aktuális processzhez, ha a PID nulla. Fatális hibát generál olyan rendszereken, amelyeken nincs implementálva. Ha az argumentumok nincsenek megadva, akkor az alapértelmezés 0,0.

Mivel POSIX-ban a setgrp nem fogad el argumentumokat, ezért csak a setgrp 0,0 a hordozható kód.

setpriority WHICH,WHO,PRIORITY
Beállítja az aktuális prioritást egy processzhez, csoporthoz, vagy felhasználóhoz. Fatális hibát generál olyan rendszereken, amelyeken nincs implementálva.

setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL
Beállítja a kért socket opciót. Visszatérési értéke undef hiba esetén. OPTVAL megadható undef-ként ha nem akarunk argumentumot megadni.

shift ARRAY

shift
Kiveszi egy tömb elsõ elemét és visszaadja visszatérési értékként. A tömb eggyel rövidebb lesz, minden egyes elemet eggyel lejjebb húzva a tömbbe. Ha a tömbben nincsenek elemek, akkor undef értéket ad vissza. Ha nincs argumentum megadva, akkor az @ARGV tömböt használja a fõprogramban, és a @_ tömböt szubrutinokban, éppen úgy, mint a pop. Ellentéte az unshift. Hasonló függvények a pop illetve ennek a párja a push.

shmctl ID,CMD,ARG
Meghívja a System V IPC shmctl rendszerhívást. Ha a CMD &IPC_STAT, akkor ARG egy olyan változó kell, hogy legyen, amely a visszaadott shmid_ds struktúrát fogja tartalmazni. A visszatérési értéke olyan, mint az ioctl függvénynek: undef hiba esetén, "0 de TRUE" zero visszatérési érték esetén, és a rendszerfüggvény által visszaadott érték egyébként.

shmget KEY,SIZE,FLAGS
Meghívja a System V IPC shmget rendszerfüggvényt. A visszatérési érték a megosztott memória szegmens azonosító, illetve undef egyébként.

shmread ID,VAR,POS,SIZE

shmwrite ID,STRING,POS,SIZE
Olvas vagy ír a System V ID azonosítójú megosztott memória szegmensbõl illetve abba, a POS pozíciótól kezdõdõen SIZE hosszan hozzáfûzve, be-, kimásolva, illetve leválasztva. Olvasáskor VAR egy változó, amely a kiolvasott értéket fogja tartalmazni. Íráskor, ha a STRING füzér túl hosszú, csak az elsõ SIZE bájtot fogja kiírni a rendszer.

Visszatérési érték TRUE siker esetén FALSE hiba esetén.

shutdown SOCKET,HOW
Lelõ egy socket kapcsolatot. A HOW paraméter adja meg a lelövés módját, éppen úgy, ahogy az azonos nevû rendszerhívásnál.

sin EXPRESSION
Az EXPRESSION kifejezés szinuszát adja vissza. Az argumentumot radiánban értelmezi. Ha nincs megadva argumentum, akkor $_ szinuszát adja vissza.

sleep EXPRESSION

sleep
A függvény hatására a program EXPRESSION másodpercre megáll, alszik, illetve meghatározatlan idõre alszik, ha nincs megadva argumentum. Ebbõl az állapotból az idõ lejártával, vagy egy SIGALRM szignállal lehet kihozni a programot. A visszatérési érték a valóban alvással eltöltött másodpercek száma.

Általában nem lehet az alarm és sleep függvényeket vegyesen használni, mert a legtöbb rendszeren a sleep függvény az alarm függvény felhasználásával van implementálva.

Néhány öregebb rendszeren egy másodperccel kevesebbet alszik a program, mint a valóban megkívánt.

Ennél finomabban beállítható várakozásra a Perl syscall függvényét lehet használni a setitimer(2) felület eléréséhez, ha ez az adott rendszeren elérhetõ, vagy a select függvényt.

socket SOCKET,DOMAIN,TYPE,PROTOCOL
Megnyitja a megfelelõ típusú socket-et és hozzárendeli a SOCKET fájlkezelõhöz. DOMAIN, TYPE és PROTOCOL ugyanazt jelentik, mint a rendszerhívás esetében.

Feltehetõleg használni kell a use Socket parancsot a megfelelõ definíciók betöltéséhez.

socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL
Létrehoz egy pár, név nélküli socket-et a definiált tartományban. DOMAIN, TYPE és PROTOCOL ugyanazt jelentik, mint a rendszerhívás esetében. Ha nincs implementálva fatális hibát ad. Visszatérési értéke TRUE siker esetén.

sort SUBNAME LIST

sort BLOCK LIST

sort LIST
A LIST listát adja vissza rendezve. A tömb nem létezõ elemeit törli. Ha SUBNAME vagy BLOCK hiányzik, akkor a szabványos füzérsorrendbe rendez. Ha SUBNAME meg van adva, akkor ez annak a szubrutinnak a neve, amely az elemi összehasonlítások eredményeképpen negatív, nulla vagy pozitív számot ad attól függõen, hogy hogyan kell rendezni a tömböt. (A <=> operátor rendkívül fontos ezekben a szubrutinokban.)

SUBNAME lehet egy skaláris változó, amely esetben a változó értéke adja meg a hasonlításokhoz használt szubrutin nevét. A SUBNAME helyén megadható egy BLOCK blokk, mint egy rövid, egyszerû szubrutin.

A hatékonyság kedvéért a szokásos szubrutinhívási eljárásokat kihagyja a rendszer, aminek a következõ következményei vannak:

  • a szubrutin nem lehet rekurzív,
  • a két hasonlítandó elem nem a szokásos @_ tömbben kerül átadásra, hanem a csomagszinten globális $a és $b változókban.
Példák:
# lexikális rendezés
@articles = sort @files;
# ugyanaz, csak most expliciten meg van adva a hasonlító blokk
@articles = sort {$a cmp $b} @files;
# kisbetû/nagybetû most nem számít
@articles = sort { uc($a) cmp uc($b)} @files;
# és ugyanez fordított sorrendben
@articles = sort {$b cmp $a} @files;
# numerikusan növekvõ sorrendbe
@articles = sort {$a <=> $b} @files;
# numerikusan csökkenõ sorrendbe
@articles = sort {$b <=> $a} @files;

# expliciten megadott szubrutin névvel
sub byage {
  $age{$a} <=> $age{$b};  # presuming integers
  }
@sortedclass = sort byage @class;
# az %age tördelõtábla kulcsai az értékek szerint
# rendezve
@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;
        # prints AbelCaincatdogx
print sort backwards @harry;
        # prints xdogcatCainAbel
print sort @george, 'to', @harry;
        # prints AbelAxedCainPunishedcatchaseddoggonetoxyz

splice ARRAY,OFFSET,LENGTH,LIST

splice ARRAY,OFFSET,LENGTH

splice ARRAY,OFFSET
Kiveszi az OFFSET és LENGTH paraméterek által meghatározott részét az ARRAY tömbnek, és helyette berakja a LIST lista elemeit, ha meg van adva lista. Visszatérési értéke a kivett elemek listája. A tömb csökken, vagy nõ, ahogy szükséges. Ha LENGTH nincs megadva, akkor az OFFSET értéktõl kezdõdõen mindent kivesz.

A következõ utasítások azonosak, (feltételezzük, hogy $[ értéke nulla):

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);

split /PATTERN/,EXPRESSION,LIMIT

split /PATTERN/,EXPRESSION

split /PATTERN/

split
Feldarabol egy füzért füzérek tömbjére, és a listát adja vissza.

Ha nem listakörnyezetben szerepel, akkor a megtalált mezõk számát adja vissza, amelyek belekerültek a @_ tömbbe. (Listakörnyezetben is rá lehet venni a split függvényt, hogy a @_ tömbbe helyezze el az elemeket azzal, hogy ?? jeleket használunk, mint reguláris kifejezés határolókat, de ekkor is a listaelemeket adja vissza a függvény. Ugyanakkor az implicit módon @_-ba történõ vágás ellenjavallt.

Ha nincsen megadva EXPRESSION kifejezés, akkor $_ értékét darabolja fel a függvény. Ha a PATTERN reguláris kifejezés sincsen megadva, akkor a szóközök mentén vágja szét a füzért a függvény (a bevezetõ szóközök után). Ha LIMIT meg van adva és pozitív, akkor legfeljebb ennyi mezõre vágja szét a füzért. Ha LIMIT nincs megadva, akkor a keletkezõ lista végén lévõ üres mezõket levágja a függvény. Ha a LIMIT negatív, akkor azt úgy kezeli a függvény, mintha tetszõlegesen nagy lenne a LIMIT.

Ha a PATTERN megfelel a null füzérnek, akkor a füzért minden egyes karakter között elvágja, így például

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

kimenete

h:i:t:h:e:r:e

A LIMIT megadásával részlegesen lehet felvágni füzéreket.

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

Amikor egy listának adunk értéket a függvénnyel, akkor a Perl automatikusan a lista elemeinek száma plusz egy értéket ad meg LIMIT-ként, ezzel is csökkentve a felesleges mûveleteket. Az elõbbi példában LIMIT értéke alapértelmezés szerint négy lett volna.

Ha a PATTERN reguláris kifejezésen belül zárójeleket használunk, akkor minden egyes részfüzérre, amely megfelel a bezárójelezett résznek egy újabb listaelem keletkezik, például:

print join(':',split(/([,-])/, "1-10,20", 3));

kimenete

1:-:10:,:20

A reguláris kifejezés PATTERN helyettesíthetõ egy változóval, amelyiknek az értéke tartalmazza a reguláris kifejezést.

sprintf FORMAT,LIST
A visszatérési értéke egy formázott füzér a C-ben megszokott printf formátumoknak megfelelõen. Az indirekt hosszat jelõlõ * karakter nem támogatott, de Perl-ben ezt sokkal egyszerûbben meg lehet oldani, csak be kell írni a változót az idézõjelek (és nem aposztrófok) közé zárt füzérbe.

sqrt EXPRESSION
Az EXPRESSION kifejezés négyzetgyökét adja vissza. Ha nincs megadva argumentum, akkor $_ négyzetgyökét számítja ki.

srand EXPRESSION
Véletlenszám kezdeti értéket ad meg a rand függvény számára. Ha az EXPRESSION kifejezés nincs megadva, akkor a pillanatnyi idõbõl, a processz azonosítóból és egyéb dolgokból állít elõ egy kezdõértéket. Titkosításhoz nem ajánlott a használata.

stat FILEHANDLE

stat EXPRESSION
Egy 13 elemû tömböt ad vissza, amely a fájl státuszát adja meg. A fájl vagy meg van nyitva és a FILEHANDLE fájlkezelõhöz rendelve, vagy EXPRESSION adja meg a nevét. Hiba esetén nulla listát ad vissza. Tipikus felhasználás:
($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
   $atime,$mtime,$ctime,$blksize,$blocks)
       = stat($filename);

Nem minden mezõ támogatott minden fájlrendszerben. Az egyes mezõk értelme:

  • dev az eszköz száma
  • ino inode száma
  • mode fájlmód, típus és engedélyek
  • nlink a hard linkeke száma a fájlhoz
  • uid a fájl tulajdonosának numerikus azonosítója
  • gid a fájlt tulajdonosának numerikus csoport azonosítója
  • rdev eszközazonosító (speciális fájloknál)
  • size a fájl teljes mérete bájtokban
  • atime a fájl utolsó hozzáférési idõpontja
  • mtime a fájl utolsó módosítási idõpontja
  • ctime az indode változásának ideje
  • blksize preferált blokk méret
  • blocks a pillanatnyilag lefoglalt blokkok száma

(Az idõpontok 1970. január 1 0:00 GMT óta eltelt másodpercekben vannak megadva, mint általában minden idõpont a UNIX-os rendszerekben.)

Ha a stat-nak egy speciális fájlnevet, az aláhúzás karaktert adjuk meg akkor nem hívja meg a rendszerfüggvényt, hanem a legutolsó fájltesztelés, vagy stat eredményeit használja.

study SCALAR

study
Megvizsgálja a megadott SCALAR füzért, illetve $_ tartalmát, hogy az ezután következõ mintaillesztéseket gyorsabban, a vizsgálat eredményének megfelelõen optimalizálva hajthassa végre. Ez vagy megspórol valamennyi idõt, vagy nem, mindig a konkrét esettõl függõen. Általában meg lehet próbálni a futást study-val és anélkül. Azok a ciklusok, amelyek sok apró konstans füzérre keresnek rá, gyorsulnak fel a leginkább.

Egy idõben csak egy ilyen vizsgálat lehet aktív. Egy második skalár megvizsgálásának hatására az elsõt elfelejti a rendszer.

sub BLOCK

sub NAME

sub NAME BLOCK
Ez nem egy beépített függvény, hanem szubrutin definíció. Csak névvel, és feltehetõleg prototípussal megadva csak egy deklaráció. Név nélkül egy olyan kifejezés, amely egy referenciát ad vissza a definiált kódszegmenshez, és névvel, és blokkal együtt szabályos szubrutin definíció.

substr EXPRESSION,OFFSET,LEN

substr EXPRESSION,OFFSET
Kiveszi az EXPRESSION kifejezésbõl a részfüzért és visszaadja értékként. Az elsõ karakter indexe 0 vagy amilyen értékre $[ lett állítva. Ha az OFFET értéke negatív, akkor ennyi karakterre a füzér végétõl kezdi a részfüzért. Ha LEN nincs megadva, akkor az OFFSET értékének megfelelõ karaktertõl a füzér végéig veszi a karaktereket. Ha LEN értéke negatív, akkor ennyi karaktert hagy meg a füzér végén. A substr függvény használható balértékként, azaz ilyen fügvvénnyel alkotott részfüzérnek értéket lehet adni, de ebben az esetben EXPRESSION is balérték kell, hogy legyen.

Ha az értékadás során a LEN értékénél kevesebb karaktert teszünk az alfüzér helyére, akkor az eredményül kapott füzér rövidebb lesz, ha többet, akkor hosszabb lesz.

Példák:

$k = "Almás deres\n";
print substr($k,2,4);
print substr($k,-6);
print substr($k,6,-1);
print substr($k,-7,-2);
substr($k,0,5) = "\nRétes";
print $k;

és a kimenet:

más deres
deres dere
Rétes deres

symlink OLDFILE,NEWFILE
Létrehoz egy szimbolikus linket NEWFILE néven, amely az OLDFILE fájlhoz lesz kapcsolva. Visszatérési értéke 1 siker esetén, és 0 egyébként. Azokon a rendszereken, amelyek a szimbolikus linkeket nem támogatják fatális hibát okoz.

syscall LIST
Meghívja a rendszerhívást, amelyet a LIST lista elsõ eleme meghatároz. Ha nincs implementálva fatális hibát okoz. Az egyes argumentumok a következõképpen kerülnek felhasználásra:
  • numerikus argumentum esetén int értéket ad át a program a rendszerhívásnak.
  • füzér argumentum esetén a füzérre mutató mutatót adja át értékként a rendszer. Ekkor a hívó feladata, hogy a füzér megfelelõen hosszú legyen a visszaadott érték fogadására.
A numerikus argumentumok esetén az egyes argumentumokhoz hozzá lehet adni nullát, hogy biztosan numerikusnak tekintse a Perl.
require 'syscall.ph';
syscall(&SYS_write, fileno(STDOUT), "ki van ott?\n", 9);


A Perl maximum 14 argumentumot ad át a rendszernek, ami a gyakorlatban elegendõ kell, hogy legyen.

sysopen FILEHANDLE,FILENAME,MODE

sysopen FILEHANDLE,FILENAME,MODE,PERMS
A FILENAME névvel megadott fájlt nyitja meg és hozzárendeli a FILEHANDLE fájlkezelõhöz. Ha FILEHANDLE egy kifejezés, akkor ennek értéke adja meg a fájlkezelõ nevét. Ez a függvény az operációs rendszer open függvényét hívja meg a FILENAME, MODE, PERMS paraméterekkel.

A lehetséges bit értékek a MODE paraméter számára rendszerfüggõk, és a szabványos Fcntl modulon keresztül érhetõk el. Ugyanakkor hagyomány okok miatt néhány érték univerzális, így nulla csak olvasásra, egy csak írásra és kettõ írásra, olvasásra nyitja meg a fájlt.

Ha a fájl nem létezik, akkor a rendszerhívás létrehozza (általában azért, mert a MODE tartalmazza az O_CREAT bitet), majd ezután a PERM engedélyezési értéket rendeli hozzá. Ha PERM hiányzik, akkor alapértelmezés szerint 0666 az értéke (vigyázat, ez oktális szám, nem sátánista jelkép) amely alapján mindenki olvashatja és írhatja a fájlt.

sysread FILEHANDLE,SCALAR,LENGTH,OFFSET

sysread FILEHANDLE,SCALAR,LENGTH
Megpróbál LENGTH bájtnyi adatot olvasni a SCALAR változóba a FILEHANDLE fájlkezelõhöz rendelt fájlból a rendszer read(2) parancsát használva. Ez a függvéyn kikerüli az stdio könyvtárat, így más olvasási mûveletekkel együtt használva zavarodástokozhat. A beolvasott bájtok számát adja vissza értékként, vagy undef értéket, ha hiba történt. SCALAR mérete csökkenni, vagy növekedni fog attól függõen, hogy hány bájtot olvasott be a rendszer. Megadható egy OFFSET érték, amely azt határozza meg, hogy a beolvasott bájtokat a SCALAR változóba hol kell elhelyezni.

system LIST
Ugyanazt teszi, mint az exec, kivéve, hogy egy fork hajtódik elõször végre, és az apa processz vár a gyerek processzre. Az argumentumkezelés függ az argumentumok számától. A visszaadott érték az a kilépési státusz érték, amelyet a wait függvény ad vissza. A valódi processz kilépési érték ennek 256-od része.

syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET

syswrite FILEHANDLE,SCALAR,LENGTH
LENGTH bájtot ír a SCALAR változóból a FILEHANDLE fájlkezelõhöz rendelt fájlba a write(2) rendszerhívás segítségével. Kihagyja a szabványos stdio könyvtárat, ezért más kiírási mûveletekkel való keverése igen érdekes, és nem kívánt eredményeket adhat. A kiírt bájtok számát adja vissza vagy undef értéket ha hiba történt. Az OFFSET értékével lehet megadni, hogy hol kezdõdik az a bájtsor amit ki kell írni, ha nem a SCALAR változó elsõ bájtjától kezdve akarunk írni.

tell FILEHANDLE

tell
Visszaadja az aktuális fájlpozíciót a FILEHANDLE fájlkezelõhöz. A FILEHANDLE fájlkezelõ lehet egy kifejezés, ilyenkor a kifejezés értéke adja meg a használandó fájlkezelõ nevét. Ha FILEHANDLE nincs megadva, akkor a legutoljára használt fájlkezelõt használja.

telldir DIRHANDLE
Visszaadja a DIRHANDLE könyvtárkezelõ aktuális pozícióját, amelyet a readdir függvény használ. A visszaadott érték adható át a seekdir függvénynek.

tie VARIABLE,CLASSNAME,LIST
Ez a függvény egy változót köt egy osztályhoz (csomaghoz), amely osztály tartalmazza a változóval végezhetõ mûveleteket. VARIABLE a változó neve. CLASSNAME az osztály neve, amely implementálja a mûveleteket. Minden további argumentumot az osztályon belüli new metódusnak ad át a rendszer. Ezek olyan argumentumok, amelyeket a C programozási nyelv dbm_open() függvényének lehet például átadni.

Az objektum, amelyet a tie függvény visszaad a new metódus által létrehozott, és visszaadott objektum.

Megjegyzendõ, hogy az olyan függvények, mint a keys vagy values igen nagy tömböket eredményezhetnek olyan tördelõtáblák esetén, amelyek nem memóriában vannak tárolva, hanem a tie függvénnyel DBM fájlokhoz vannak rendelve. Ilyen esetben sokkal inkább az each függvényt kell használni, amely egyenként veszi elõ az egyes elemeket.

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);

Az osztály, amely egy tördelõtáblát hoz létre a következõ metódusokat kell, hogy megvalósítsa:

  • TIEHASH CLASSNAME, LIST
  • DESTROY this
  • FETCH this, key
  • STORE this, key, value
  • DELETE this, key
  • EXISTS this, key
  • FIRSTKEY this
  • NEXTKEY this, lastkey

Az osztály, amely közönséges tömböt valósít meg a következõ metódusokat kell, hogy megvalósítsa:

  • TIEARRAY CLASSNAME, LIST
  • DESTROY this
  • FETCH this, key
  • STORE this, key, value

Az osztály, amely skalárt valósít meg a következõ metódusokat kell, hogy megvalósítsa:

  • TIESCALAR CLASSNAME, LIST
  • DESTROY this
  • FETCH this,
  • STORE this, value

Ellentétben a dbmopen függvénnyel a tie függvény nem olvas be semmilyen modult, ezt a programnak egy külön require vagy use függvénnyel kell megtennie, ha szükséges.

tied VARIABLE
Ahhoz az objektumhoz ad egy referenciát, amelyet a tie függvény adott vissza, amikor a változót egy osztályhoz kötötte. Ha a változó nem lett semmilyen osztályhoz kötve, akkor undef értéket ad vissza.

time
A másodpercek számát adja meg, amely a kezdetek óta eltelt. (Ez 1904 január 1. 00:00:00, a MacOS operációs rendszeren, más rendszereken 1970 január 1. 00:00:00 gmt) Ez az érték adható át argumentumként a gmtime vagy localtime függvényeknek.

times
Egy négyelemû tömböt ad vissza, amely a processz és a gyermek processzek által elfogyasztott felhasználói és rendszer idõt adja meg.
($user,$system,$cuser,$csystem) = times;

tr///
A transzlációs operátor.

truncate FILEHANDLE,LENGTH

truncate EXPRESSION,LENGTH
Levágja a fájl végét, amelynek a nevét az EXPRESSION kifejezés adja meg, vagy a FILEHANDLE fájlkezelõhöz van rendelve. Fatális hibát ad olyan rendszeren ahol nincs implementálva.

uc EXPRESSION
A nagybetûs változatát adja vissza az EXPRESSION kifejezésnek. Ez a belsõ függvény, amely megvalósítja az idézõjelek közötti \U escape szekvenciát. Minden POSIX setlocale() beállítást figyelembe kell vennie.

ucfirst EXPRESSION
Az EXPRESSION kifejezést adja vissza, az elsõ betût nagybetûre konvertálva. Ez a belsõ függvény, amely megvalósítja az idézõjelek közötti \u escape szekvenciát. Minden POSIX setlocale() beállítást figyelembe kell vennie.

umask EXPRESSION

umask
Beállítja a processz számára az umask értékét, és a régit adja vissza. Ha EXPRESSION nincs megadva, akkor nem állít semmit, csak az aktuális umask értéket adja vissza.

undef EXPRESSION

undef
Az EXPRESSION kifejezés által megadott balértéket teszi nem definiálttá. Skalárra, tömbre és szubrutinra alkalmazható. Mindig nem definiált értéket ad vissza. Ha az EXPRESSION kifejezés hiányzik, akkor semmi más hatása nincs, mint a nem definiált értéket adja vissza, amelyet például fel lehet használni, mint szubrutin visszatérési értéket.
undef $foo;
undef $bar{'blurfl'};
undef @ary;
undef %assoc;
undef &mysub;
return (wantarray ? () : undef) if $they_blew_it;

unlink LIST
Törli a LIST listában megadott fájlokat. A sikeresen törölt fájlok számát adja meg.

Megjegyzés: az unlink nem töröl könyvtárakat, csak akkor ha superuser módban fut a processz, és a Perl a -U kapcsolóval lett elindítva. Azonban még ebben az esetben is gondokat okozhat a fájlrendszerben egy könyvtár fájlként való eltávolítása. Sokkal biztonságosabb módszer az rmdir használata.

unpack TEMPLATE,EXPRESSION
Az unpack a pack ellentéte: az EXPRESSION kifejezésben megadott füzért a TEMPLATE-nek megfelelõen bontja fel értékekre, és ezek listáját adja vissza. Skalár környezetben az elsõ értéket adja vissza. A TEMPLATE formátuma ugyanaz, mint a pack függvénynél.

A következõ példaprogram a substr és ord függvényeket valósítja meg:

sub substr {
    local($what,$where,$howmuch) = @_;
    unpack("x$where a$howmuch", $what);
}
sub ord { unpack("c",$_[0]); }

Ezen túlmenõen minden mezõjelölõ karaktert megelõzhet egy %<xxx> jelölés, amely esetben nem a mezõ értékét adja meg az unpack hanem annak xxx bites ellenõrzõ összegét. A következõ példa a System V sum parancsát valósítja meg:

while (<>) {
    $checksum += unpack("%16C*", $_);
}
$checksum %= 65536;

A következõ példa hatékonyan számolja össze egy bitvektor bitjeit:

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

untie VARIABLE
Megszünteti a hozzárendelést egy változó és egy osztály között, amelyet a tie hozott létre.

unshift ARRAY,LIST
A shift függvény ellentéte. A LIST listát fûzi az ARRAY tömb elejére és az így kapott új tömb elemeinek a számát adja vissza.

A LIST lista egésze, egyszerre lesz a tömb elejére illesztve, így a sorrend a tömb elején ugyan az lesz, mint a listában. Ha nem ez a kívánatos, akkor a reverse függvénnyel lehet a LIST lista elemeinek sorrendjét megfordítani.

use Module LIST

use Module

use Module VERSION LIST

use VERSION
Beimportál egy modult, és általában, a modultól függõen néhány szubrutin nevet az importáló modulban elhelyez. A hatása ugyanaz, mint a
    BEGIN { require Module; import Module LIST; }

utasításnak, kivéve, hogy a Module a use esetében fix szó kell, hogy legyen, nem lehet füzér kifejezés.

Ha az elsõ argumentum nem modul név, hanem szám, akkor a Perl megvizsgálja, hogy a saját verziója eléri-e ezt az értéket, és ha nem, akkor egy hibajelzés után azonnal leáll. Ezzel lehet megkövetelni azt a Perl verziót, amely alatt a program hibásan hajtódna végre.

A use estében a modul beimportálása fordítási idõben történik, ezt a fenti ekvivalens példában a BEGIN éri el. Az import nem egyéb, mint egy, a modulban definiált statikus szubrutin, amely általában neveket rak át az importáló csomag névterületére. A modul olyan módon implementálhatja saját import szubrutinját, ahogy csak akarja, de a legtöbb csomag csak egyszerûen örökli az Exporter csomagból.

Ha az importáló nem akarja, hogy a névterülete megváltozzon, akkor a

    use Module ();

alakot kell használni, amely ekvivalens a

    BEGIN { require Module; }

formával.

Ha a VERSION szerepel a Modul és a LIST lista között, akkor a use hibát okoz, ha a csomagban a $VERSION változó értéke kisebb, mint VERSION.

Mivel ez a formátum megfelelõen nyitott, ezért sok fordítási direktíva is ebben a formában van megvalósítva. A pillanatnyilag implementált direktívák:

    use integer;
    use diagnostics;
    use sigtrap qw(SEGV BUS);
    use strict  qw(subs vars refs);
    use subs    qw(afunc blurfl);

Ezek a pszeudo modulok a pillanatnyi blokk környezetben fejtik ki a hatásukat ellentétben az igazi modulokkal, amelyek a névtartományt módosítják, és így a fájl végéig hatásosak.

Van egy no parancs, amely a use ellentéte, és amely ennek megfelelõen nem az import, hanem az unimport szubrutint hívja meg.

utime LIST
Megváltoztatja a hozzáférési és a módosítási idejét a LIST listában szereplõ fájloknak. A lista elsõ két argumentuma a numerikus idõérték a hozzáférési és módosítási idõre. Visszatérési értéke a sikeresen módosított fájlok száma. Ugyanakkor az inode módosítási idõ az aktuális idõ lesz. Példaképp a touch program egy egyszerû megvalósítása:
#!/usr/bin/perl
$now = time;
utime $now, $now, @ARGV;

values ASSOC_ARRAY
A visszatérési értéke egy tömb, amely a tördelõtábla értékeit tartalmazza. Skaláris környezetben az elemek számát adja vissza. A visszaadott tömbben az értékek sorrendje nem meghatározott, de definiáltan ugyan az, mint a kulcsokra a keys függvény által visszaadott tömbbeli sorrend, vagy az each függvény által biztosított sorrend.

vec EXPRESSION,OFFSET,BITS
Az EXPRESSION kifejezést, mint olyan bitsort értelmezi, amelyben BITS darabnyi bitet tartalmazó csomagok vannak egymás után, és az OFFSET értéke által megadott csomagot adja értékként. Ha a vec függvényt, mint balértéket kezeljük, akkor természetesen az EXPRESSION kifejezésnek is balértéknek kell lennie, és használni kell a zárójeleket a megfelelõ végrehajtási sorrend eléréséhez.

Az így kezelt vektorokkal a logikai bitenkénti |, & és ^ használhatók.

#!/usr/bin/perl
vec($v,3,8)=64;
print unpack("b*", $v),"\n";
vec($v,9,1)=1;
vec($v,11,1)=1;
print unpack("b*", $v),"\n";
vec($v,0,3)=255;
print unpack("b*", $v),"\n";

és a kimenet

00000000000000000000000000000010
00000000010100000000000000000010
11100000010100000000000000000010

wait
Vár egy gyermekprocessz leállására, és a leálló processz azonosítóját adja vissza, illetve -1 értéket, ha nincs futó gyermekprocessz. A leálló processz státusza a $? változóba kerül.

waitpid PID,FLAGS
Egy azonosítójával adott gyermekprocessz lefutására vár, és a leálló processz azonosítóját adja vissza, illetve -1 értéket, ha nincs ilyen azonosítójú futó gyermekprocessz. A leálló processz státusza a $? változóba kerül.

wantarray
A visszatérési értéke TRUE, ha az aktuális szubrutinhívás listakörnyezetbõl történik. Tipikus felhasználás:
    return wantarray ? () : undef;

warn LIST
Egy figyelmeztetõ üzenetet ír a szabványos hibakimenetre, de nem áll le, mint a die.

write FILEHANDLE

write EXPRESSION

write
Egy formátumozott, és akár többsoros rekordot ír a FILEHANDLE fájlkezelõhöz rendelt fájlba. A formátum alapértelmezés szerint az a formátum, amelynek ugyanaz a neve, mint a fájlkezelõnek, de a pillanatnyi kimenti csatornához (select) formátumot lehet rendelni: a $~ változónak a formátum nevét kell adni értékként.

A lapteteje automatikusan kezelõdik, ha nincs elegendõ hely az oldalon a rekord számára, akkor egy lapdobást ír ki a fájlba, majd a lap teteje fejlécet, és utána az aktuális rekordot. Alapértelmezés szerint a fejléc a fájlkezelõ neve, amelyhez a _TOP karaktereket adja hozzá a rendszer, de tetszõlegesen átállítható, csupán a $^ változóhoz kell a formátum nevét rendelni, miközben a fájlkezelõ van kiválaszva a select függvénnyel. A lapon fennmaradó sorok száma a $- változóba kerül, amelynek nulla értéket adva lapdobást lehet elérni a következõ kiírásnál.

Ha a FILEHANDLE nincs megadva, akkor a kiírás az aktuális kimeneti csatornába megy, amely alapértelmezés szerint STDOUT, de megváltoztatható a select függvénnyel. Ha a FILEHANDLE helyett egy kifejezés van megadva, akkor a kifejezés adja meg a fájlkezelõ nevét.

Megjegyzés: a write NEM a read ellentéte.

y///
A transzlációs operátor (ugyanaz, mint tr).