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.
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.
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.
Á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 _;
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.
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.
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.
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õ.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Ez igazából nem egy függvény, hanem egy programvezérlési kulcsszó.
Ha egy BLOCK-hoz csatlakozik egy continueBLOCK, 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.
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.
[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);
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"; }
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.
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:
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.
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.
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.
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 gotoLABEL 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.
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";
}
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.
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.
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.
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
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.
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);
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.
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();
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);
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.
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";
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ó.
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.
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:
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:
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
Á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:
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.
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.
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.
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.
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.
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.
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.
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.
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.
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++;
}
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.
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.
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.
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.
Á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:
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.
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.
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.
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é.
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.
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.
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.
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.
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.
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.
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.
Az EXPRESSION kifejezés által megadott nevû könyvtárat nyitja meg, hogy a
readdir,
telldirseekdirrewinddir
é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.
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
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.
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.
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.
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.
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.
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
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.
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.
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.
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;
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.
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.
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.
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";
}
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.
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.
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.
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.
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.
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.
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.
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);
}
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.
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:
Egy write vagy print függvény ezt a fájlkezelõt fogja használni, ha
más fájlkezelõ nincs megadva.
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:
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.
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.
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.
Ü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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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):
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.
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.
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.
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.
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:
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.
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.
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ó.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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:
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.
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.
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:
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.
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.
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.
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.
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.