A Perl programozási nyelv

Alapok

Adatstruktúrák, Lexikális elemek

Öt adatstruktúra található a nyelvben: skalár, skalárok tömbje, az asszociatív tömb, a Perl által hívható szubrutin, és a globális adattípus hivatkozás bármely ilyen nevű adattípusra. Ezeket - mint azt későbbiekben látni fogjuk - mutatókkal is lehet kombinálni, így lényegében mindenféle adatstruktúrát megalkothatunk. A normál tömbök indexe - általában - 0-val kezdődik (lásd még itt). Az asszociatív tömböket szövegekkel kell indexelni.

A változó nevének első karaktere határozza meg annak típusát:

Ez az első karakter a változónak a kifejezésben betöltött szerepét kell, hogy takarja.

Példák:

$days # egyszerű skalár $days[3] # days nevű tömb negyedik eleme @days # az egész tömb ($days[0], .. , $days[$#days]) $days{'Feb'} # days nevű asszociatív tömb egy eleme %days # az egész asszociatív tömb (kulcs, érték párok) $#days # days tömb utolsó indexe &kiir(); # a kiir() függvényt hívó parancssor

Az alprogramokat & jellel megjelölhetjük, ha az alprogramot deklarációja előtt szeretnénk használni, vagy az alprogram címét akarjuk egy változóban eltárolni. Függvényre a deklarációja után már a & szimbólum nélkül is hivatkozhatunk (ez - a nyelv előző verziójától eltérően - minden függvényre alkalmazható).

A változók nevei egyébként a típusuknak megfelelő külön szimbólumtáblába kerülnek, tehát használhatunk azonos nevu tömböt, asszociatív tömböt és skalárt. (Ekkor $ize[0] az @ize tömb része, nem pedig az $ize változót helyettesíti.)

A változók nevei betűvel vagy aláhúzásjellel kell, hogy kezdődjenek, és tetszőleges alfanumerikus karakterrel, illetve aláhúzásjellel folytatható. A változónevek érzékenyek a kis- és nagybetűs írásmódra.
A változó neve nem kell, hogy megadott legyen, akár egy kifejezés is állhat helyette, melynek aktuális értéke lesz a valódi név!

Példa:

$p="p"; ${$p x 3} = "PPP"; # A "ppp" változó értéke "PPP" lesz

Vannak speciális változónevek alapvető paraméterek jelölésére. Ezek az Előre definiált változók részben megtalálhatóak.

Környezet

A kifejezés típusa a kifejezés környezetétől is függhet!

Például az int(<STDIN>) eredménye egy egész szám lesz, amit a bemenet egy sorából állít elő az int függvény, de a sort(<STDIN>) eredménye egy lista lesz, amit a bemenet összes sorának beolvasása után a sort függvény rendezéssel állít elő!

Skalárok

Skalár változók sokféle értéket tárolhatnak: szám, szöveg, bináris adat vagy mutató. A tartalom a használat során mindig szükséges formára alakul, azaz kiírhatunk egy számot szövegként egy változóba, majd ezt a változót megszorozhatjuk kettővel.

Az alábbiakban lássunk néhány skalár értéket (literált):

A Perl saját magán belül az egészeket lebegőpontos számként ábrázolja. Ez azt jelenti, hogy egy egész skalár érték egy speciális lebegőpontos skalár érték. A Perl különbséget tesz " és ' között. Idézőjelek között elvégzi a változók és a speciális karakterek helyettesítését, apósztrófok között nem.

$bela = "rossz!"; $feri = "Ez $bela"; # most $feri "Ez rossz!" $jani = 'Ez $bela'; # $jani pedig 'Ez $bela'

Továbbá lehetőségünk van idézőjelek között megadott szöveg esetén a ", $ és \ karakterek megadására, ezek elé elhelyezett \ karakterrel. Hasonló módon érhetjük el ezt aposztrófok közti karakterlánc esetében a \ és ' karakterekre.

print("\$bela: \"$bela\"."); # kiírodik: $bela: "rossz!". print('Itt egy aposztrof: \'.'); # kiírodik: Itt egy aposztrof: '.
Példák:
$i = 2; # egész $f = 2.3; # racionális $szam = 1_000_000_000; # ez egy nagy egész (a _ csak a jobb olvashatóságot szolgálja) $hexa = 0xffeedd; # hexadecimális szám $szoveg = "Ez egy szoveg"; # egy szöveg $szoveg = <<VEGE; # hosszabb szöveg megadása Valami # "Itt a dokumentum" stílusú VEGE # adatbevitellel (VEGE a zárószimbólum) fv(<<EGY, <<KETTO); # ez itt is működik első paraméter EGY második paraméter KETTO

Az aritmetikai műveleteknél a számok bináris formára konvertálódnak, így ezek pontosságát a processzor korlátozza. Vannak persze kiegészítő modulok tetszőleges pontosságú számok kezelésére is.

Feltételek vizsgálatánál csak az üres szöveg, illetve a 0 érték jelent hamisat. Tipp: ha valahol szükség van "0, de igaz" értékre, akkor ezt a "0+0E" stringgel érhetjük el. Ennek logikai értéke "igaz", viszont ha számolunk vele, akkor 0-vá konvertálódik.

A skalár változóknak alapvetően két állapota lehet: definiált, vagy definiálatlan. Ezeket a defined, illetve undefined függvényekkel kérdezhetjük le. Egy változó addig definiálatlan, amíg valaki nem ad neki értéket, vagy nem definiálja explicit módon. Definiálatlan változónak - a környezetétől függően - 0 vagy üres szöveg értéke van. Ha a Perl interpretert a "-w" kapcsolóval indítjuk (ez megadható pl. a script első sorában: #!/usr/local/bin/perl -w, windows esetén a perl -w filename.pl sort kell futtatni), akkor definiálatlan változóra való hivatkozás esetén figyelmeztetést kapunk.

#!/usr/local/bin/perl $szam = $undef + 2; # $undef nem definialt print("A \$szam erteke $szam.\n"); # Az output: A $szam erteke 2

A skaláris adatokkal a megszokott műveletek végezhetők a megszokott műveleti jelekkel. Ami eltérő lehet: a számok esetében a hatványozás művelet a ** műveleti jellel, a modulus a % jellel valamint a karakterekre a . összefűzés művelet, az összehasonlító (FORTRAN-szeru) eq, ne, lt, gt, le, ge, cmp műveletek és az ismétlő műveleti jel: x. Fontos beépített függvény a chomp, amely egy karakterlánc végéről levágja a \n jelet. A skalár változók a használat során mindig a megfelelő formára konvertálódnak, ezáltal írhatunk a műveleti jelek használatakor eltérő típusú változókat is egy kifejezésben.

Példák:

$lanc = $lanc . " "; # szóköz hozzáfűzése a $lanchoz $alma = "körte" x (3 + 1); # azaz "körtekörtekörtekörte" $mastipus = (3 + 2) x 4; # "5555" karakterlánc

Megjegyzés:

  1. Ha egy string karakterei közt nincs számjegy, akkor a string 0-vá konvertálódik egész környezetben való használatakor.
    $szam = "hello" * 5; # $szam 0, mert "hello" 0-va konvertálódik

  2. Egy string egésszé történő konvertálásakor a Perl balról indulva halad jobbra, amíg egy olyan betuhöz nem ér, ami nem számjegy.
    $szam = "12o34"; # az o betu, nem a 0 szamjegy; ekkor a $szam 12-ve konvertalodik, nem pedig 12034-e

Listák és Tömbök

A Perl-ben használt tömböket inkább indexelt listáknak kéne nevezni a kiterjeszthetőségük miatt.

Egy lista zárójelek közt felsorolt skalár értékeket jelent. A lista akármilyen hosszúságú lehet és tetszőleges skalár értéket tartalmazhat.

(1, 5.3, "hello", 2) # egyszerű példa () #ures lista # Listaelemkent használhatunk egy kifejezés értéként: (17, 26 << 2) # listaelemek: 17 es 104 (26 balratoltja 2 hellyel)
Listákat un. tömbváltozókban (v. röviden tömbökben) tárolhatunk, melyekre való hivatkozások a @ karakterrel kezdődnek.
@napok = ('He','Ke','Sze','Csu','Pe','Szo','Va'); print(@napok); print($napok[4]);
Az első sor létrehozza és feltölti a tömböt. Az értékeket egy listával adtuk meg, de ezt sok egyéb módon is megtehetjük. A második parancs hatására kiíródik az egész tömb tartalma, hiszen a @napok-kal az egész tömbre hivatkozunk. Ha a tömb egy elemére vagyunk kíváncsiak, akkor az már egy skalár érték, tehát egy skalár változó tartalma. Egy elemre a [] jelek közé tett indexszel hivatkozhatunk, és a tömb neve elé $-t írunk, hisz skalár értékre vagyunk kíváncsiak. Erre látunk példát a harmadik sorban, ami kiírja, hogy "Pe", mert az indexelés 0-val kezdődik.

Értékadásokban (rész)tömböket is értékül adhatunk. Ezekben az esetekben a balérték listája az első elemtől kezdve addig töltődik fel, amíg van új elem a jobb oldalon. Az értékadás akkor és csak akkor érvényes, ha a baloldalon legális balértékek szerepelnek.

($a, $b, $c) = (1, 2, 3); # a változók sorban értéket kapnak ($a, $b, @maradek) = @valami; # ez is helyes
Tömb balértékként használata csak utolsó elemnek érdemes, mert egy korábbi tömb az összes jobboldalt magába olvassa. Ez jó a lokális paraméterek átvételénél. Értékadásnál a résztömbök automatikusan elemenként bemásolódnak, így a keletkező tömb homogén lesz:
@tomb = (@lista1, @lista2, &alprg)

A $[ változó mutatja, hogy a tömbök melyik indexen kezdődnek ( ez a C-ben 0 ). Ennek értéke módosítható (bár módosítása ellenjavalt), ezért a következő két értékadás ekvivalens:

@tomb = (); # üressé teszi a tömböt $#tomb = $[ - 1; # a tömb hosszát -1-re állítja
Skalár környezetben a tömb kiértékelése a tömb aktuális hosszát adja vissza:
@tomb = (1, 2, 3); $skalar = @tomb; # $skalar erteke 3 @tomb2 = (15, "este", -8, 'valami'); $i = 1; while ($i <= @tomb2){ # $i <= 4 print("$i. elem: $tomb2[$i-1]\n"); $i++; }
Műveletek listákon és tömbökön:

Asszociatív tömbök (hash)

A hash is skaláris adatok gyűjteménye, csak itt az indexek nem feltétlenül nem negatív kicsi egészek, hanem tetszőleges skalárok. Ezek a kulcsok, amiket használunk az elemek elérésére. A hash-eknek nincs sorrendjük, így ezt nem is lehet irányítani - a Perl maga dönti el, milyen belső sorrendben tárolja őket.

A hash változók is megegyeznek a skalároknál leírtakkal, csak % jellel kezdődnek. A hivatkozás {}-el történik.

%szinek = ( # asszociatív tömb 'piros' , 0x00f, # egyszerű felsorolás, párosával 'kék' , 0x0f0, 'zöld' , 0xf00, ); %szinek = ( # ugyanaz csak jobban olvashatóan 'piros' => 0x00f, 'kék' => 0x0f0, 'zöld' => 0xf00 ); print(@szinek{'piros','zold'});
Egy asszociatív tömb skalár környezetben visszaadja, hogy van-e benne kulcs-érték pár. Ez csupán arra jó, hogy a hash-elő algoritmus hatékonyságát vizsgáljuk.

A hash változókra a keys függvény a kulcsok listáját adja vissza, a values pedig az értékeket. delete-el lehet kulcs szerint törölni, az each függvény pedig ciklusokban jól használható, mivel végigmegy a hash-en visszaadva a kulcs-érték párokat. Az exists függvény használható annak tesztelésére, hogy egy adott kulcs szerepel-e a hash táblában.

Példák: hash.pl

# "elso" kulcsához "valami" hozzárendelése az uj hash-táblában $uj{"elso"} = "valami"; # hash tömbből: kulcs-érték párokból kell állnia a tömbnek %korte = @alma; # végignézzük a neveket while ($k, $v) = each(%nevek) {&#65533;} # ha a kulcsok szerint rendezve akarunk végigmenni az értékeken foreach $k (sort keys %nevek) {...;$v=$nevek{$k};...} # kulcs tesztelése print "Már van ilyen\n" if exists $nevek{'Kis Józsi'};

Szubrutin (alprogram) adattípus

A Perl - hasonlóan a többi modern programnyelvhez - módot ad arra, hogy ún. szubrutinokat (függvényeket) készítsünk, ezáltal kibővítve a programozás lehetőségeit. A szubrutinokat egy & jellel és egy névvel azonosítjuk.
A Perlben a szubrutin használatához írjuk be a & jelet és a szubrutin nevét oda, ahol a függvényt futtatni akarjuk.

Példa:

$elso =13;
$masodik =24;
$nagyobb = &max($elso, $masodik);
print $nagyobb;

sub max{
my $max = shift(@_);
foreach $arg (@_) {
$max = $arg if $max < $arg;
}
return $max;
} # Kiválasztja a két szám közül, hogy melyknek nagyobb az értéke.

Globális adattípus

A globális adattípus teljes szimbólumtáblán használható, ugyanúgy, mint egy tömb vagy egy hash (asszociatív tömb).
A Perl korábbi verzióiban a globális adattípusokat ott használták, ahol függvényeknek adtunk át tömböket. A Perl 5. verziójában erre már nem használunk globális adattípusokat.
A globális adattípus jele a * , tehát a globális adattípus minden más adattípust képvisel.

Példa:

*lista = *arulista;
Ekkor az áruk listájához úgy férhetünk hozzá a $lista-n keresztül, mintha a $arulista-t használnánk.

Szintaxis, utasítások

A Perl program utasítások és deklarációk egymásutánja, amelybe megjegyzéseket a # jel használatával tehetünk. Ennek hatására a Perl interpreter a sor végéig lévő szövegrészt megjegyzésnek tekinti.

A nyelvben az utasítások és deklarációk szabadon - akár keverve is, mint egy C++ programban - követhetik egymást. Megkötés csak az alprogramok hívására van: a még nem deklarált alprogramot csak a & szimbólum használatával lehet meghívni.

Egyszerű utasítás

Operátorok és operandusok egy gyűjteményét kifejezésnek nevezzük. Minden kifejezés egy eredményt ad, ezen értéket kapjuk, amikor a Perl interpreter kiértékeli a kifejezést (azaz amikor a Perl interpreter végrehajtja a meghatározott operátorokat; például a 4*5 kifejezés kiértékelésekor a 20 eredményt kapjuk). A kifejezésekből építhetjük fel utasításainkat, melyeket a pontosvessző zár le. Például a $var = 4; utasítás a $var = 4 kifejezést tartalmazza egy pontosvesszővel lezárva. Perlben üres utasítás nincs (nem úgy, mint a C-ben, ahol ez a ;).

Egy utasítás után egy módosító kifejezés állhat, amely ennek az egyetlen utasításnak a hatását befolyásolja:

utasítás if EXPR # végrehajtja az utasítást, ha EXPR igaz utasítás unless EXPR # végrehajtja utasítást, ha EXPR hamis utasítás while EXPR # addig ismétli az utasítást, amíg EXPR igaz marad utasítás until EXPR # addig ismétli az utasítást, amíg EXPR igazzá nem válik
Fontos megjegyezni, hogy ez a while ill. until módosító nem minősül ciklusnak, így ciklusvezérlő utasítások nem használhatók rájuk. Ez különösen akkor érdekes, ha az utasítás egy do:
do { ... # "ciklusmag", de mégsem az last if $quit; # HIBÁS!!! } while ($lepesszam < 1000);
A do esetében a while ill. az until módosító feltétele az utasítás végrehajtása után értékelődik ki, minden más esetben a feltétel kiértékelése az utasítás végrehajtása előtt történik.

Egy üzenet kiírása feltételtől függően:

print "Hello kedves olvasó!\n" if $bobeszedu_program;
Egy kis elgondolkodtató példa:
$a = 1; print "Hello1\n"; if ($a == 2) { print "World1!\n"; } print "Hello2\n" if ($a == 2); { print "World2!\n"; }

Összetett utasítás

Itt kell megemlíteni a BLOKK fogalmát, amely { és } jelekkel közbezárt utasítássorozat. (Itt fontosak a { és } jelek, még egyetlen utasításnál is!) A BLOKK tetszőleges számú legális Perl utasításból állhat (akár tartalmazhat 0 számú utasítást, ekkor azt ÜRES BLOKKnak nevezzük).

Ez alapján a lehetséges formák:

# BLOKK végrehajtódik ha az EXPR igaz if (EXPR) BLOKK # ha EXPR igaz akkor BLOKK1, egyébként BLOKK2 lesz végrehajtva if (EXPR) BLOKK1 else BLOKK2 if (EXPR) BLOKK elsif (EXPR) BLOKK ... else BLOKK
Az if utasítás szintaxisa itt egyértelmű lesz, mivel a BLOKK nem állhat egyetlen utasításból.
CIMKE while (EXPR) BLOKK CIMKE while (EXPR) BLOKK continue BLOKK CIMKE until (EXPR) BLOKK
A while ciklus törzsében végrehajtott next utasítás hatására a vezérlés a continue BLOKK-ra kerül, majd újra elindul a ciklusmag. Az EXPR kifejezés a continue BLOKK lefutása után értékelődik ki újra.
CIMKE for (EXPR1; EXPR2; EXPR3) BLOKK
Ez a szokásos C-beli ciklus formája. A következő két forma ekvivalens:
for($i = 1; $i < 10; $i++) { $i = 1; ... while($i < 10) { } ... } continue { $i++; }
CIMKE foreach változó (TOMB) BLOKK
Ez a shell-ekben meglévő ciklus egy változata. Itt a változó sorban felveszi a TOMB elemeit értékül, és így indul el a ciklusmag.
CIMKE BLOKK continue BLOKK
Ez a végtelen ciklus volt...

Vezérlésátadó utasítások:

last; : a ciklus végrehajtása megszakítódik és a vezérlés a ciklust követő utasításra kerül.
next; : a ciklus aktuális iterációját befejezi és a következő iterációt indítja.
redo; : az aktuális iterációt újraindítja.
goto CIMKE; : a CIMKE címkéjű utasításra ugrik.
A last, next, redo utasítások után megadhatunk címkét is, mellyel többszintű ugrásokat érhetünk el.
CIMKE while ...
last CIMKE; : kilép a CIMKE címkéju ciklusból (példa).
next CIMKE; : a CIMKE címkéju ciklus következő iterációját indítja.
redo CIMKE; : a CIMKE címkéju ciklus aktuális iterációját újraindítja.

A switch utasításra nincs külön forma, de van rá egypár lehetséges más megoldás, például:

SWITCH: { /^abc/ && do { $abc = 1; last SWITCH; }; /^def/ && do { $def = 1; last SWITCH; }; /^xyz/ && do { $xyz = 1; last SWITCH; }; $nothing = 1; }
Ahol a last utasítás a megnevezett BLOKK elhagyására szolgál. A /^abc/ alakú feltételek mintaillesztésre szolgálnak. Ha egy minta illeszkedik a $_ változó tartalmához, akkor a hozzá tartozó feltétel második tagja is kiértékelésre kerül, azaz a do utasítás is végrehajtódik.

Van két speciális eset, ami pont úgy néz ki, mintha blokk lenne, de mégis egyetlen egyszerű utasításnak minősül. Az egyik a már korábban is említett do, a másik a (többek között) kivételkezelésre használt eval:

do { # ez nem ciklus, bár ránézésre nagyon hasonlít $line = <stdin>; chomp $line; } until ($line eq 'exit'); eval { somefunc(); }; # mivel nem blokk, KELL a ';' if ($@) { # ez már egy rendes blokk die("somefunc() elszállt\n"); }

Operandusok és precedenciájuk

A C nyelvben érvényes szabályok érvényesek, és még van egypár - shell script-ekből ismerős - új operátor.
operátor
kiértékelés iránya
leírás
lista (,) balról jobbra kifejezések listája
-> balról jobbra hivatkozás
++,-- nem asszociatív növelés, csökkentés
** jobbról balra hatványozás
!, ~, \ és unáris +, - jobbról balra nem, bináris nem, címoperátor, +, -
=~, !~ balról jobbra szöveg illeszkedés, nem illeszkedés
*, /, %, x balról jobbra szorzás, osztás, modulus, ismétlés
+, -, . balról jobbra összeadás, kivonás, konkatenáció
<<, >> balról jobbra balra, illetve jobbra shift
unáris operátorok nem asszociativ pl. file tesztelés: -f
<, >, <=, >=, =, lt, gt, le, ge nem asszociatív szám illetve szöveg összehasonlítása
==, !=, <=>, eq, ne, cmp nem asszociatív szám illetve szöveg összehasonlítása
& balról jobbra bináris AND
|, ^ balról jobbra bináris OR és XOR
&& balról jobbra logikai AND
|| balról jobbra logikai OR
.. nem asszociatív tartomány
?: jobbról balra feltételes értékadás
=, +=, -=, *= ... jobbról balra értékadás operátorai
, => balról jobbra vessző és kulcs operátor
lista operátorok nem asszociatív lista manipulációk
not balról jobbra logikai NOT
and balról jobbra logikai AND
or, xor balról jobbra logikai OR, eXclusive OR



operátor
példa
leírás
= $a = "Valami szöveg\n"; egyszerű értékadás
+= $szam += 2; $szam = $szam+2;
-= $szam -= 2; $szam = $szam-2;
.= $string .= "még valami"; $string = $string . "még valami";
*= $szorzat *= 3; $szorzat = $szorzat * 3;
/= $valos /= 5; $valos = $valos / 5;
%= $mod %= 2; $mod = $mod % 2;
x= $string x= 5; $string = $szting x 5;
|= $a |= $b; $a = $a | $b;
^= $a ^= $b; $a = $a ^ b;
<<= $a <<= $b; $a = $a << $b;
>>= $a >>= $b; $a = $a >> $b;
&&= $a &&= $b; $a = $a && $b;
||= $a ||= $b; $a = $a || $b;
A Perl értékadó operátorai

Itt csak az ismeretlennek tunő operátorokat fogom kiemelni:

címoperátor
olyan mint a C nyelv & operátora; visszaadja az operandus objektum címét (alprogramokra is megy!) pl: \$a
ismétlés
egy szöveget meg lehet ismételni néhányszor, pl.: "ha" x 3 == "hahaha"
konkatenáció
szövegek összefuzése, pl.: "ha" . "ha" == "haha"
file tesztelés
ezek a shell programokban megszokott file tesztelő operátorok, pl.: -f "hello.c" akkor igaz, ha a hello.c file létezik
szöveg összehasonlítás
Erre a lt,gt,le,ge,eq,ne operátorok szolgálnak. Ha szövegeket az == operátorokkal hasonlítgatjuk, akkor azok memóriabeli címei kerülnek összehasonlításra, nem tartalmai!
cmp
értéke -1, 0, vagy 1 lehet a szövegektől függően.
szám összehasonlítás
Szokásos operátorokon kívül a <=> szerepel itt. Ennek -1 az értéke, ha az első szám nagyobb, 1, ha a második, és 0, ha egyenlő a két szám. Ez az operátor - az előbb említett cmp operátorhoz hasonlóan - főleg rendezéseknél használható jól.
I/O
Az alapvető és legfontosabb I/O operátor a < és a >. Ha egy file leíróját ilyen jelek közé rakjuk, akkor egy sort olvashatunk belőle. A beolvasott sor automatikusan a $_ változóhoz rendelődik, ha nem adunk meg mást.
Egy egyszerű cat (UNIX cat parancs) így is leírható:
while(<STDIN>) { print $_; # print; is lehetne, hiszen az $_ az # alapertelemezett argumentum }
A szövegekhez még járul egy pár "idézőjel" operátor: A C nyelvben érvényes szabályok érvényesek, és még van egypár - shell script-ekből ismerős - új operátor.
operátor
kiértékelés iránya
leírás
lista (,) balról jobbra kifejezések listája
-> balról jobbra hivatkozás
++,-- nem asszociatív növelés, csökkentés
** jobbról balra hatványozás
!, ~, \ és unáris +, - jobbról balra nem, bináris nem, címoperátor, +, -
=~, !~ balról jobbra szöveg illeszkedés, nem illeszkedés
*, /, %, x balról jobbra szorzás, osztás, modulus, ismétlés
+, -, . balról jobbra összeadás, kivonás, konkatenáció
<<, >> balról jobbra balra, illetve jobbra shift
unáris operátorok nem asszociativ pl. file tesztelés: -f
<, >, <=, >=, =, lt, gt, le, ge nem asszociatív szám illetve szöveg összehasonlítása
==, !=, <=>, eq, ne, cmp nem asszociatív szám illetve szöveg összehasonlítása
& balról jobbra bináris AND
|, ^ balról jobbra bináris OR és XOR
&& balról jobbra logikai AND
|| balról jobbra logikai OR
.. nem asszociatív tartomány
?: jobbról balra feltételes értékadás
=, +=, -=, *= ... jobbról balra értékadás operátorai
, => balról jobbra vessző és kulcs operátor
lista operátorok nem asszociatív lista manipulációk
not balról jobbra logikai NOT
and balról jobbra logikai AND
or, xor balról jobbra logikai OR, eXclusive OR



operátor
példa
leírás
= $a = "Valami szöveg\n"; egyszerű értékadás
+= $szam += 2; $szam = $szam+2;
-= $szam -= 2; $szam = $szam-2;
.= $string .= "még valami"; $string = $string . "még valami";
*= $szorzat *= 3; $szorzat = $szorzat * 3;
/= $valos /= 5; $valos = $valos / 5;
%= $mod %= 2; $mod = $mod % 2;
x= $string x= 5; $string = $szting x 5;
|= $a |= $b; $a = $a | $b;
^= $a ^= $b; $a = $a ^ b;
<<= $a <<= $b; $a = $a << $b;
>>= $a >>= $b; $a = $a >> $b;
&&= $a &&= $b; $a = $a && $b;
||= $a ||= $b; $a = $a || $b;
A Perl értékadó operátorai

Itt csak az ismeretlennek tűnő operátorokat fogom kiemelni:

címoperátor
olyan mint a C nyelv & operátora; visszaadja az operandus objektum címét (alprogramokra is megy!) pl: \$a
ismétlés
egy szöveget meg lehet ismételni néhányszor, pl.: "ha" x 3 == "hahaha"
konkatenácó
szövegek összefuzése, pl.: "ha" . "ha" == "haha"
file tesztelés
ezek a shell programokban megszokott file tesztelő operátorok, pl.: -f "hello.c" akkor igaz, ha a hello.c file létezik
szöveg összehasonlítás
Erre a lt,gt,le,ge,eq,ne operátorok szolgálnak. Ha szövegeket az == operátorokkal hasonlítgatjuk, akkor azok memóriabeli címei kerülnek összehasonlításra, nem tartalmai!
cmp
értéke -1, 0, vagy 1 lehet a szövegektől függően.
szám összehasonlítás
Szokásos operátorokon kívül a <=> szerepel itt. Ennek -1 az értéke, ha az első szám nagyobb, 1, ha a második, és 0, ha egyenlő a két szám. Ez az operátor - az előbb említett cmp operátorhoz hasonlóan - főleg rendezéseknél használható jól.
I/O
Az alapvető és legfontosabb I/O operátor a < és a >. Ha egy file leíróját ilyen jelek közé rakjuk, akkor egy sort olvashatunk belőle. A beolvasott sor automatikusan a $_ változóhoz rendelődik, ha nem adunk meg mást.
Egy egyszerű cat (UNIX cat parancs) így is leírható:
while(<STDIN>) { print $_; # print; is lehetne, hiszen az $_ az # alapertelemezett argumentum }

A szövegekhez még járul egypár "idézőjel" operátor:

általában hivatalos jelölés értelme megjegyzés
'...' q{} szöveg literál ez a "szó szerinti" szöveg literál
"..." qq{} szöveg literál változókat helyettesíti a szövegben (pl. "$a", "\n")
`...` qx{} parancs az adott szöveget, mint egy shell parancssort végrehajtja
qw{} a szövegből egy szólistát csinál pl.: paraméterátadás
// m{} mintaillesztés változókat értékükkel helyettesíti
s// s{}{} csere változókat értékükkel helyettesíti
tr{}{} betucsere a szövegeket mint cseretáblát használja

Példák:

$a = 6; $b = q{$a}; # $b = "$a" $b = qq{$a}; # $b = 6

Mintaillesztés

Használat
A C nyelvben érvényes szabályok érvényesek, és még van egypár - shell script-ekből ismerős - új operátor.
operátor
kiértékelés iránya
leírás
lista (,) balról jobbra kifejezések listája
-> balról jobbra hivatkozás
++,-- nem asszociatív növelés, csökkentés
** jobbról balra hatványozás
!, ~, \ és unáris +, - jobbról balra nem, bináris nem, címoperátor, +, -
=~, !~ balról jobbra szöveg illeszkedés, nem illeszkedés
*, /, %, x balról jobbra szorzás, osztás, modulus, ismétlés
+, -, . balról jobbra összeadás, kivonás, konkatenáció
<<, >> balról jobbra balra, illetve jobbra shift
unáris operátorok nem asszociativ pl. file tesztelés: -f
<, >, <=, >=, =, lt, gt, le, ge nem asszociatív szám illetve szöveg összehasonlítása
==, !=, <=>, eq, ne, cmp nem asszociatív szám illetve szöveg összehasonlítása
& balról jobbra bináris AND
|, ^ balról jobbra bináris OR és XOR
&& balról jobbra logikai AND
|| balról jobbra logikai OR
.. nem asszociatív tartomány
?: jobbról balra feltételes értékadás
=, +=, -=, *= ... jobbról balra értékadás operátorai
, => balról jobbra vessző és kulcs operátor
lista operátorok nem asszociatív lista manipulációk
not balról jobbra logikai NOT
and balról jobbra logikai AND
or, xor balról jobbra logikai OR, eXclusive OR



operátor
példa
leírás
= $a = "Valami szöveg\n"; egyszerű értékadás
+= $szam += 2; $szam = $szam+2;
-= $szam -= 2; $szam = $szam-2;
.= $string .= "még valami"; $string = $string . "még valami";
*= $szorzat *= 3; $szorzat = $szorzat * 3;
/= $valos /= 5; $valos = $valos / 5;
%= $mod %= 2; $mod = $mod % 2;
x= $string x= 5; $string = $szting x 5;
|= $a |= $b; $a = $a | $b;
^= $a ^= $b; $a = $a ^ b;
<<= $a <<= $b; $a = $a << $b;
>>= $a >>= $b; $a = $a >> $b;
&&= $a &&= $b; $a = $a && $b;
||= $a ||= $b; $a = $a || $b;
A Perl értékadó operátorai

Itt csak az ismeretlennek tűnő operátorokat fogom kiemelni:

címoperátor
olyan mint a C nyelv & operátora; visszaadja az operandus objektum címét (alprogramokra is megy!) pl: \$a
ismétlés
egy szöveget meg lehet ismételni néhányszor, pl.: "ha" x 3 == "hahaha"
konkatenácó
szövegek összefuzése, pl.: "ha" . "ha" == "haha"
file tesztelés
ezek a shell programokban megszokott file tesztelő operátorok, pl.: -f "hello.c" akkor igaz, ha a hello.c file létezik
szöveg összehasonlítás
Erre a lt,gt,le,ge,eq,ne operátorok szolgálnak. Ha szövegeket az == operátorokkal hasonlítgatjuk, akkor azok memóriabeli címei kerülnek összehasonlításra, nem tartalmai!
cmp
értéke -1, 0, vagy 1 lehet a szövegektől függően.
szám összehasonlítás
Szokásos operátorokon kívül a <=> szerepel itt. Ennek -1 az értéke, ha az első szám nagyobb, 1, ha a második, és 0, ha egyenlő a két szám. Ez az operátor - az előbb említett cmp operátorhoz hasonlóan - főleg rendezéseknél használható jól.
I/O
Az alapvető és legfontosabb I/O operátor a < és a >. Ha egy file leíróját ilyen jelek közé rakjuk, akkor egy sort olvashatunk belőle. A beolvasott sor automatikusan a $_ változóhoz rendelődik, ha nem adunk meg mást.
Egy egyszerű cat (UNIX cat parancs) így is leírható:
while(<STDIN>) { print $_; # print; is lehetne, hiszen az $_ az # alapertelemezett argumentum }

A szövegekhez még járul egypár "idézőjel" operátor:

általában hivatalos jelölés értelme megjegyzés
'...' q{} szöveg literál ez a "szó szerinti" szöveg literál
"..." qq{} szöveg literál változókat helyettesíti a szövegben (pl. "$a", "\n")
`...` qx{} parancs az adott szöveget, mint egy shell parancssort végrehajtja
qw{} a szövegből egy szólistát csinál pl.: paraméterátadás
// m{} mintaillesztés változókat értékükkel helyettesíti
s// s{}{} csere változókat értékükkel helyettesíti
tr{}{} betucsere a szövegeket mint cseretáblát használja

Példák:

$a = 6; $b = q{$a}; # $b = "$a" $b = qq{$a}; # $b = 6

Mintaillesztés

Szövegkeresés netovábbja.

Használat

A mintaillesztést több dologra is lehet használni a =~ vagy a !~ operátorokkal:
Módosítók
A C nyelvben érvényes szabályok érvényesek, és még van egypár - shell script-ekből ismerős - új operátor.
operátor
kiértékelés iránya
leírás
lista (,) balról jobbra kifejezések listája
-> balról jobbra hivatkozás
++,-- nem asszociatív növelés, csökkentés
** jobbról balra hatványozás
!, ~, \ és unáris +, - jobbról balra nem, bináris nem, címoperátor, +, -
=~, !~ balról jobbra szöveg illeszkedés, nem illeszkedés
*, /, %, x balról jobbra szorzás, osztás, modulus, ismétlés
+, -, . balról jobbra összeadás, kivonás, konkatenáció
<<, >> balról jobbra balra, illetve jobbra shift
unáris operátorok nem asszociativ pl. file tesztelés: -f
<, >, <=, >=, =, lt, gt, le, ge nem asszociatív szám illetve szöveg összehasonlítása
==, !=, <=>, eq, ne, cmp nem asszociatív szám illetve szöveg összehasonlítása
& balról jobbra bináris AND
|, ^ balról jobbra bináris OR és XOR
&& balról jobbra logikai AND
|| balról jobbra logikai OR
.. nem asszociatív tartomány
?: jobbról balra feltételes értékadás
=, +=, -=, *= ... jobbról balra értékadás operátorai
, => balról jobbra vessző és kulcs operátor
lista operátorok nem asszociatív lista manipulációk
not balról jobbra logikai NOT
and balról jobbra logikai AND
or, xor balról jobbra logikai OR, eXclusive OR



operátor
példa
leírás
= $a = "Valami szöveg\n"; egyszerű értékadás
+= $szam += 2; $szam = $szam+2;
-= $szam -= 2; $szam = $szam-2;
.= $string .= "még valami"; $string = $string . "még valami";
*= $szorzat *= 3; $szorzat = $szorzat * 3;
/= $valos /= 5; $valos = $valos / 5;
%= $mod %= 2; $mod = $mod % 2;
x= $string x= 5; $string = $szting x 5;
|= $a |= $b; $a = $a | $b;
^= $a ^= $b; $a = $a ^ b;
<<= $a <<= $b; $a = $a << $b;
>>= $a >>= $b; $a = $a >> $b;
&&= $a &&= $b; $a = $a && $b;
||= $a ||= $b; $a = $a || $b;
A Perl értékadó operátorai

Itt csak az ismeretlennek tűnő operátorokat fogom kiemelni:

címoperátor
olyan mint a C nyelv & operátora; visszaadja az operandus objektum címét (alprogramokra is megy!) pl: \$a
ismétlés
egy szöveget meg lehet ismételni néhányszor, pl.: "ha" x 3 == "hahaha"
konkatenácó
szövegek összefuzése, pl.: "ha" . "ha" == "haha"
file tesztelés
ezek a shell programokban megszokott file tesztelő operátorok, pl.: -f "hello.c" akkor igaz, ha a hello.c file létezik
szöveg összehasonlítás
Erre a lt,gt,le,ge,eq,ne operátorok szolgálnak. Ha szövegeket az == operátorokkal hasonlítgatjuk, akkor azok memóriabeli címei kerülnek összehasonlításra, nem tartalmai!
cmp
értéke -1, 0, vagy 1 lehet a szövegektől függően.
szám összehasonlítás
Szokásos operátorokon kívül a <=> szerepel itt. Ennek -1 az értéke, ha az első szám nagyobb, 1, ha a második, és 0, ha egyenlő a két szám. Ez az operátor - az előbb említett cmp operátorhoz hasonlóan - főleg rendezéseknél használható jól.
I/O
Az alapvető és legfontosabb I/O operátor a < és a >. Ha egy file leíróját ilyen jelek közé rakjuk, akkor egy sort olvashatunk belőle. A beolvasott sor automatikusan a $_ változóhoz rendelődik, ha nem adunk meg mást.
Egy egyszerű cat (UNIX cat parancs) így is leírható:
while(<STDIN>) { print $_; # print; is lehetne, hiszen az $_ az # alapertelemezett argumentum }

A szövegekhez még járul egypár "idézőjel" operátor:

általában hivatalos jelölés értelme megjegyzés
'...' q{} szöveg literál ez a "szó szerinti" szöveg literál
"..." qq{} szöveg literál változókat helyettesíti a szövegben (pl. "$a", "\n")
`...` qx{} parancs az adott szöveget, mint egy shell parancssort végrehajtja
qw{} a szövegből egy szólistát csinál pl.: paraméterátadás
// m{} mintaillesztés változókat értékükkel helyettesíti
s// s{}{} csere változókat értékükkel helyettesíti
tr{}{} betucsere a szövegeket mint cseretáblát használja

Példák:

$a = 6; $b = q{$a}; # $b = "$a" $b = qq{$a}; # $b = 6

Reguláris kifejezések

Szövegkeresés netovábbja.

Használat

A mintaillesztést több dologra is lehet használni a =~ vagy a !~ operátorokkal:

Módosítók

A // után általában írhatunk valamilyen karaktert, ami a keresést egy kicsit módosítja:
Mintaillesztési opciók
i kis- és nagybetuket nem különbözteti meg
m többsoros szövegben keres
s a szöveget egyetlen sorként kezeli
x kibővített reguláris kifejezések használata
g összes találat megkeresése
c a g módosító használatakor sikertelen keresés esetén ne nullázza a keresési pozíciót
o csak egyszer fordítsa le a kifejezést, ne minden kiértékeléskor

Operátor opciói
i kis- és nagybetuket nem különbözteti meg
m a szöveget többsorosként kezeli
s a szöveget egyetlen sorként kezeli
x a szóközt figyelmen kívül hagyja a mintában
g a minta összes előfordulását cseréli
c a g módosító használatakor sikertelen keresés esetén ne nullázza a keresési pozíciót
o csak egy kiértékelést végez
e a helyettesítő stringet kifejezésként értékeli

A fordítás operátor opciói
s kicseréli a többszörösen azonos kimenő karaktereket egy karakterre
c az összes nem meghatározott karaktert fordítja
d törli az összes meghatározott karaktert

Az i módosító használatával így a /perl/i kifejezés a PeRL szövegre is illeszkedni fog. Egy ilyen kifejezésben egy szöveghez illeszthető mintát lehet leírni. Ebbe a mintába persze belevehetünk extra dolgokat is, hogy a nekünk szükséges részt nyerjük ki a szövegből. (A UNIX grep parancsában megszokott dolgok a () csoportosító operátortól eltekintve.) A C nyelvben érvényes szabályok érvényesek, és még van egypár - shell script-ekből ismerős - új operátor.

operátor
kiértékelés iránya
leírás
lista (,) balról jobbra kifejezések listája
-> balról jobbra hivatkozás
++,-- nem asszociatív növelés, csökkentés
** jobbról balra hatványozás
!, ~, \ és unáris +, - jobbról balra nem, bináris nem, címoperátor, +, -
=~, !~ balról jobbra szöveg illeszkedés, nem illeszkedés
*, /, %, x balról jobbra szorzás, osztás, modulus, ismétlés
+, -, . balról jobbra összeadás, kivonás, konkatenáció
<<, >> balról jobbra balra, illetve jobbra shift
unáris operátorok nem asszociativ pl. file tesztelés: -f
<, >, <=, >=, =, lt, gt, le, ge nem asszociatív szám illetve szöveg összehasonlítása
==, !=, <=>, eq, ne, cmp nem asszociatív szám illetve szöveg összehasonlítása
& balról jobbra bináris AND
|, ^ balról jobbra bináris OR és XOR
&& balról jobbra logikai AND
|| balról jobbra logikai OR
.. nem asszociatív tartomány
?: jobbról balra feltételes értékadás
=, +=, -=, *= ... jobbról balra értékadás operátorai
, => balról jobbra vessző és kulcs operátor
lista operátorok nem asszociatív lista manipulációk
not balról jobbra logikai NOT
and balról jobbra logikai AND
or, xor balról jobbra logikai OR, eXclusive OR



operátor
példa
leírás
= $a = "Valami szöveg\n"; egyszerű értékadás
+= $szam += 2; $szam = $szam+2;
-= $szam -= 2; $szam = $szam-2;
.= $string .= "még valami"; $string = $string . "még valami";
*= $szorzat *= 3; $szorzat = $szorzat * 3;
/= $valos /= 5; $valos = $valos / 5;
%= $mod %= 2; $mod = $mod % 2;
x= $string x= 5; $string = $szting x 5;
|= $a |= $b; $a = $a | $b;
^= $a ^= $b; $a = $a ^ b;
<<= $a <<= $b; $a = $a << $b;
>>= $a >>= $b; $a = $a >> $b;
&&= $a &&= $b; $a = $a && $b;
||= $a ||= $b; $a = $a || $b;
A Perl értékadó operátorai

Itt csak az ismeretlennek tűnő operátorokat fogom kiemelni:

címoperátor
olyan mint a C nyelv & operátora; visszaadja az operandus objektum címét (alprogramokra is megy!) pl: \$a
ismétlés
egy szöveget meg lehet ismételni néhányszor, pl.: "ha" x 3 == "hahaha"
konkatenácó
szövegek összefuzése, pl.: "ha" . "ha" == "haha"
file tesztelés
ezek a shell programokban megszokott file tesztelő operátorok, pl.: -f "hello.c" akkor igaz, ha a hello.c file létezik
szöveg összehasonlítás
Erre a lt,gt,le,ge,eq,ne operátorok szolgálnak. Ha szövegeket az == operátorokkal hasonlítgatjuk, akkor azok memóriabeli címei kerülnek összehasonlításra, nem tartalmai!
cmp
értéke -1, 0, vagy 1 lehet a szövegektől függően.
szám összehasonlítás
Szokásos operátorokon kívül a <=> szerepel itt. Ennek -1 az értéke, ha az első szám nagyobb, 1, ha a második, és 0, ha egyenlő a két szám. Ez az operátor - az előbb említett cmp operátorhoz hasonlóan - főleg rendezéseknél használható jól.
I/O
Az alapvető és legfontosabb I/O operátor a < és a >. Ha egy file leíróját ilyen jelek közé rakjuk, akkor egy sort olvashatunk belőle. A beolvasott sor automatikusan a $_ változóhoz rendelődik, ha nem adunk meg mást.
Egy egyszerű cat (UNIX cat parancs) így is leírható:
while(<STDIN>) { print $_; # print; is lehetne, hiszen az $_ az # alapertelemezett argumentum }

A szövegekhez még járul egypár "idézőjel" operátor:

általában hivatalos jelölés értelme megjegyzés
'...' q{} szöveg literál ez a "szó szerinti" szöveg literál
"..." qq{} szöveg literál változókat helyettesíti a szövegben (pl. "$a", "\n")
`...` qx{} parancs az adott szöveget, mint egy shell parancssort végrehajtja
qw{} a szövegből egy szólistát csinál pl.: paraméterátadás
// m{} mintaillesztés változókat értékükkel helyettesíti
s// s{}{} csere változókat értékükkel helyettesíti
tr{}{} betucsere a szövegeket mint cseretáblát használja

Példák:

$a = 6; $b = q{$a}; # $b = "$a" $b = qq{$a}; # $b = 6

Mintaillesztés

Szövegkeresés netovábbja.

Használat

A mintaillesztést több dologra is lehet használni a =~ vagy a !~ operátorokkal:

Módosítók

A // után általában írhatunk valamilyen karaktert, ami a keresést egy kicsit módosítja:
Mintaillesztési opciók
i kis- és nagybetuket nem különbözteti meg
m többsoros szövegben keres
s a szöveget egyetlen sorként kezeli
x kibővített reguláris kifejezések használata
g összes találat megkeresése
c a g módosító használatakor sikertelen keresés esetén ne nullázza a keresési pozíciót
o csak egyszer fordítsa le a kifejezést, ne minden kiértékeléskor

Operátor opciói
i kis- és nagybetuket nem különbözteti meg
m a szöveget többsorosként kezeli
s a szöveget egyetlen sorként kezeli
x a szóközt figyelmen kívül hagyja a mintában
g a minta összes előfordulását cseréli
c a g módosító használatakor sikertelen keresés esetén ne nullázza a keresési pozíciót
o csak egy kiértékelést végez
e a helyettesítő stringet kifejezésként értékeli

A fordítás operátor opciói
s kicseréli a többszörösen azonos kimenő karaktereket egy karakterre
c az összes nem meghatározott karaktert fordítja
d törli az összes meghatározott karaktert

Az i módosító használatával így a /perl/i kifejezés a PeRL szövegre is illeszkedni fog. Egy ilyen kifejezésben egy szöveghez illeszthető mintát lehet leírni. Ebbe a mintába persze belevehetünk extra dolgokat is, hogy a nekünk szükséges részt nyerjük ki a szövegből. (A UNIX grep parancsában megszokott dolgok a () csoportosító operátortól eltekintve.)

Az alapok

\ a következő karakter speciális jelentését elveszti
^ a sor elejéhez illeszkedik
. egy tetszőleges karakterhez illeszkedik (kivéve az újsort)
$ sor végéhez illeszkedik
| alternatívák jelölése
() csoportosítás
[] karakter-osztály kijelölése

A . csak akkor fog az újsor karakterhez illeszkedni, ha erre az s módosítóval külön megkérjük, pl.:

$szoveg = <<VEGE; Tobbsoros szoveg, amelyben a PERL perl szavakat kell majd megtalalni. VEGE print "illeszkedik/s\n" if $szoveg =~ m/PERL.perl/s; # igaz print "illeszkedik/\n" if $szoveg =~ m/PERL.perl/; # hamis
A sor eleje és vége inkább rekord elejét és végét jelenti, hiszen a nyelvben meg lehet határozni, hogy mi választja el a sorokat ($*). Alapesetben ez persze az újsor karakter, de ezt meg lehet változtatni...

karaktersorozatok

Egy egyszerű kifejezés ismétlődését a következőkkel lehet jelölni:
* 0 vagy több
+ 1 vagy több
? 0 vagy 1
{n} pontosan n-szer
{n,} legalább n-szer
{n,m} legalább n-szer, de legfeljebb m-szer

Alapértelmezés szerint az (n,m) esetén a leghosszabb ismétlődés fog illeszkedni ezekhez a részekhez. Ha minimális számú illeszkedést szeretnénk, akkor mindegyik után odatehetjük a ? jelet:

"hhhhhh" =~ m/h{2,4}/; # itt "hhhh" fog illeszkedni "hhhhhh" =~ m/h{2,4}?/; # itt csak "hh"

Speciális karakterek

\t tabulátorjel
\n újsor (New Line)
\r kocsi vissza (Carriage Return)
\f lapdobás (Form Feed)
\v vertical tab
\a csengő
\e escape
\033 oktális számrendszerben megadott karakter
\x1b karakter hexadecimálisan
\c[ kontrol karakter
\l kisbetu
\u nagybetu
\L kisbetu \E-ig
\U nagybetu \E-ig
\E kisbetu/nagybetu módosítás vége
\Q metakarakterek letiltása \E-ig
\w "szó" karakter (alfanumerikus és _)
\W nem-szó karakter
\s whitespace
\S nem whitespace
\d számjegy
\D nem számjegy
\b szóhatárhoz illeszkedik
\B nem szóhatár
\A string elejéhez illeszkedik
\Z string vége vagy az előtte levő újsor karakter
\z string vége
\G oda illeszkedik, ahol az előző illesztés véget ért

A szóhatár (\b) olyan pont két karakter között, aminek egyik oldalán \w, a másik oldalán \W karakter áll (tetszőleges sorrendben). A \A és a \Z ugyanolyan, mint a ^ ill. a $, de az m módosító használatakor is csak egyszer illeszkednek (a ^ ill. a $ többször is illeszkedhet). Ha a szöveg végi újsor karaktert nem akarjuk eldobni, akkor a \z-t kell használni. A \G akkor jó, amikor a g módosító használatával az összes egyezést meg akarjuk keresni.

Az x módosító használatával még lehet használni más dolgokat is, de ezek szerintem már csak igen-igen ritkán kerülnek elő (pl. a bonyolult kifejezéseket fel lehet darabolni, hogy könnyebben olvashatóak legyenek, megjegyzéseket lehet írni a kifejezés közepébe stb.).

?? Használata

Ellentétben a // operátorral csak egyszer illeszti az adott mintát a szöveghez.
$string = " ... egy fertály óra alatt kiseperte a vályogkunyhót.";
if $string =~ ?fertály {
print "Mi a fertály?\n";
}
Főleg ciklusokban használjuk ahol a mintaillesztés eredményét felszeretnénk használni a ciklusból való kilépés után.
while($input=<SDTIN>){
print $input;
if ($input =~ ?\bv\b? {last}
reset;
}
A reset hatására a ?? mintaillesztő újra lefut egészen addig amíg az inputról be nem olvas egy v-ét. (/b jelzi, hogy minta határáig nézi szöveget, vagyis v olvasásakor kilép a ciklusból).

Egy pár hasznos szabályos kifejezés mintaillesztére:

Fordítási operátor

Fordítási operátor:

Nem használ szabályos kifejezést hanem simán megvizsgál egy stringet egy megadott karakterlistát keresve és ezt egy másik, előre megadott karakterlistára cseréli fel.
tr/KeresettLista/CsereLista/

Példa egy szöveg kisbetus karaktereit nagybetusre váltjuk át:
$string="Itt az ideje, hogy minden jóravaló ember hazatérjen!";
$string=tr/a-z/A-Z/;

$ek_szama=tr/e/e/; #megszámolja az e-ék számát a $stringben. és ezt az értéket adja át az ek_szama változónak.

Abban az esetben, ha a cserélendő lista hosszabb mint a helyettesítő lista, akkor a helyettesítő lista utolsó elem ismétlődni fog.
$_="12345678";
tr/5678/123;
print $_ #eredménye: 12341233

Példa: tr.pl

Csoportosítás

Fordítási operátor:

Nem használ szabályos kifejezést hanem simán megvizsgál egy stringet egy megadott karakterlistát keresve és ezt egy másik, előre megadott karakterlistára cseréli fel.
tr/KeresettLista/CsereLista/

Példa egy szöveg kisbetűs karaktereit nagybetűsre váltjuk át:
$string="Itt az ideje, hogy minden jóravaló ember hazatérjen!";
$string=tr/a-z/A-Z/;

$ek_szama=tr/e/e/; #megszámolja az e-ék számát a $stringben. és ezt az értéket adja át az ek_szama változónak.

Abban az esetben, ha a cserélendő lista hosszabb mint a helyettesítő lista, akkor a helyettesítő lista utolsó elem ismétlődni fog.
$_="12345678";
tr/5678/123;
print $_ #eredménye: 12341233

Példa: tr.pl

Csoportosítás

Ha egy szövegből részeket ki akarunk nyerni, akkor a () karaktereket kell használnunk. Ha ezekkel bezárunk egy karaktersorozatot a reguláris kifejezésben, akkor az ahhoz illeszkedő karakterekre máshol is hivatkozhatunk. A minta-kifejezésen belül a \1, \2, \3, ... hivatkozásokat kell használni, a mintán kívül pedig a $1, $2, $3, ... alakot.
s/^([^ ]*) *([^ ]*)/$2 $1/; # első két szó felcserélése if ($szo =~ m/(\w+) \1/) { # pl. "ha ha" illeszkedik rá ... } if (`date` =~ m/(..):(..):(..)/) { # idő kiírása print "ora: $1, perc: $2, masodperc: $3\n"; }
Ha lista környezetben használjuk az illesztést, akkor az illeszkedő részkifejezéseket közvetlenül is megkaphatjuk:
($ora, $perc, $masodperc) = (`date` =~ m/(..):(..):(..)/);
Ha valami miatt nincs szükség egy részkifejezésre (pl. túl sok lenne belőlük), akkor a "(...)" helyett a "(?:...)" alakot használhatjuk. Az utolsó illesztett részkifejezést a $+ változó tartalmazza, a teljes illesztett stringet pedig a $& változó. Az illeszkedés előtti substringet megkapjuka a $`, az illeszkedés utánit a $' változóban. Figyelem: a $&, $` és $' használata lelassítja a program muködését, mert ezen változók karbantartásához minden egyes mintaillesztésnél extra munka kell. Ezért jobb ezeket kerülni, ha csak lehet. Ha viszont egyszer szükség volt valamelyikre, onnantól kezdve szabadon lehet őket használni, mert az árukat már megfizettük.

A Perl még sok érdekességet tud mintaillesztésben, ha az előzőeknél többre van szükség, vegyük elő a dokumentációt. Következzen most egy bonyolultabb példa: van-e a szövegben 'aaaa', és ha igen, hány darab 'a' betű van még előttük? Figyelem, a megoldás egyetlen minta!

$_ = 'a' x 8; m< (?{ $cnt = 0 }) # Beágyazott kód ( a # Számoljuk az 'a' betűket (?{ # Vigyázunk a visszalépésnél local $cnt = $cnt + 1; }) )* aaaa (?{ $res = $cnt }) >x # Kiterjesztett kifejezés volt
Eredményül a $res változóba 4 kerül.