Összeállította: Kosztyán Zsolt Tibor

Az előadások a következő témára: "Összeállította: Kosztyán Zsolt Tibor"— Előadás másolata:

1 Összeállította: Kosztyán Zsolt Tibor kzst@vision.vein.hu
PERL Összeállította: Kosztyán Zsolt Tibor

2 A PERL alapjai A Perl programnyelv alkotója, Larry Wall eredetileg rendszeradminisztrációs feladatokra szánta, de mára rengeteget fejlődött, szinte mindenre használható. Egy interpretált nyelvről van szó, mely annyit takar, hogy a "gép nyelvére" való fordítás futtatási időben történik. Fordító szinte az összes platformra létezik, legyen az Unix, Windows, Mac, stb. További előny, hogy ellentétben más programnyelvekkel, a „teljes” Perl ingyenes, szabadon letölthető a Perl weboldalról: A nyelv tanulása egyszerű, és gyorsan megy, különösen, ha már ismersz más nyelve(ke)t is. Talán épp ezért olyan elterjedt, hiszen az interaktív, CGI-ket használó weboldalak nagy részét Perl-el készítették.

3 Helló világ! Talán kezdjük is el, nézzünk meg egy minimális programot, amely a "Helló világ!" szöveget írja ki: print "Helló világ!\n"; #kiírja, hogy Helló világ! A programot futtatva kiíródik az üzenet. A fenti egy sorról már sok mindenre lehet következtetni. Mint látható, a kiírás a print utasítással történik. A C-hez hasonlóan a szövegek nem tartalmaznak sortörés karaktert, ezt nekünk kell kitenni, a \n szolgálja ezt a szerepet. A sort (mindig) pontosvessző zárja, ez kötelező. Kommenteket #-al írhatunk, a # után következő karaktereket a Perl nem értelmezi.

4 Adattípusok A Perl nyelv 5 adattípust ismer, ezek közül most néggyel fogunk részletesebben foglalkozni. Mindegyik típus külön azonosító jellel rendelkezik. Ezek a következők: Skalár változó ($) - egyszerű sztring, vagy szám Tömb - tömb (több skalár), számmal indexelve (0-tól indul) Hash (%) - tömb, sztringgel indexelve (kulcs-érték párok) Szubrutin (&) - egy szubrutint (alprogramot) hív meg Globális (*) - bármely ugyanolyan nevű adattípusra hivatkozik A változó nevének első karaktere határozza meg annak típusát. Nézzünk néhány példát: $valtozo #egyszerű, skalár változó $tomb[3] #tomb nevű tömb 4. elemére való hivatkozás (a számozás 0-tól indul) @tomb #tomb nevű tömb egésze $sash{'kulcs'} #sash nevű, sash kulcs indexű értéke %sash #sash nevű sash egésze

5 Változók A változók típusoktól függően külön tárolódnak, ergo két különböző típusú változónak lehet ugyanaz a neve. Például. az $valami[0] első eleme, nem az $valami skalár. Skalár változók A skalár adattípus egyszerű szám vagy sztring (karaktersorozat) tárolására alkalmas, nevét egy $-nak kell megelőznie. Értékadáshoz az értékadó operátort használjuk, egy egyenlőségjelet (=) - az operátorokról később lesz szó. Nézzünk meg egy egyszerű példát: $nev = "Kiss István"; $kor = 35; Itt a $nev változó a Kiss István értéket kapta, a $kor pedig a 35-öt. Mint látható, sztring esetén idézőjelet kell használni, ez számnál elhagyható. A sorvégi pontosvessző kötelező!

6 Változók Egy változóhoz hozzárendelhetjük egy másik változó értékét is: $evszam = 1990; $szam = $evszam; #$szám érteke 1990 lesz Szövegek összefűzése az alábbi módon történik: $valami = "x"."y"; #$valami érteke xy lesz. Skalár változók felhasználhatók sztringen belül is, ekkor a változó beszúrását a Perl végrehajtja: $nev = "Minta Péter"; $udvozlet = "Helló, én $nev vagyok."; Ekkor a $udvozlet tartalma "Helló, én Minta Péter vagyok." lesz (idézőjelek nélkül természetesen).

7 Változók Nézzünk meg egy érdekesebb példát! $nev = "Minta Péter";
$udvozlet = 'Helló, én $nev vagyok.\n'; print $udvozlet; A képernyőre a következő szöveg kerül kiírásra: Helló, én $nev vagyok.\n De miért? Az ok a használt idézőjelekben keresendő. Ugyanis mint látható, itt nem kettős (") idézőjelet használtam, csak szimplát. A Perl a sztringen belüli beszúrást csak " használata esetén végzi el. Itt ejtenék szót az általános levédő karakterről is, mely használatával " idézőjelek között is lehetséges a változóbeszúrás elkerülése. Például: $nev = "Minta Péter"; $szoveg = "Az \$nev változó tartalma: $nev"; print $szoveg; A fenti kódrész ezt írja ki: Az $nev változó tartalma: Minta Péter Ha a levédő karaktert szeretnénk kiíratni, akkor önmagát kell önmagával levédeni, azaz: \\

8 Tömbök Egy tömbben több skalár tárolására van lehetőségünk. Ez az egyik legalapvetőbb adatstruktúra, minden nyelvben megtalálható. A Perl-ben a tömbök kezelése dinamikus, mely azt jelenti, hogy ellentétben más nyelvekkel automatikusan kapják a méretüket, és ez automatikusan nő illetve csökken. A tömb előzi meg. Létrehozáskor zárójelek között kell felsorolni az elemeket, az alábbi módon: @allatok = ("kutya","cica","madár","csiga","hal"); Egy allatok nevű tömböt hoztunk létre, mely 5 elemet tartalmaz. Az elemeknél lehetőség van skalárok, vagy tömbök beszúrására is, nézzünk erre is egy példát! $allat = "viziló"; @madarak = ("papagáj","veréb","kakukk","strucc"); @allatok = A fenti példában először egy $allat változót hoztunk létre, mely a viziló értéket kapta. Aztán tömb következett, melyben madarakat soroltunk fel. Végül tömböt készítettünk, mely megkapta az $allat, és tartalmát is, és még néhány elemet. Ezzel tartalma a következő lett: kecske, víziló, őz, papagáj, veréb, kakukk, strucc, egér

9 Tömbök Most nézzük meg, hogyan hivatkozhatunk a tömb egyes elemeire!
@evszakok = ("tavasz","nyár",„ősz","tél"); print "A tömb első eleme: $evszakok[0]."; A program kiírja: tömb első eleme: tavasz. Mint látod, az elemek számozása nullától indul, erre oda kell figyelni! Ezzel a formával tömbök létrehozása, illetve már létező tömbök elemeinek megváltoztatása is lehetséges: @evszakok = ("tavasz","nyár","nyár","tél"); print "A tömb harmadik eleme: $evszakok[2].\n"; $evszakok[2] = „ősz"; print "A tömb harmadik eleme: $evszakok[2]."; A fenti kódsor először tömb 3. elemének a nyár-t nevezi meg, majd a megváltoztatás után az ősz-t.

10 Tömbök Ha a tömböt egy skalárhoz rendeljük hozzá, akkor az a tömb hosszát (az elemek számát) kapja értékül. Például: @szinek = ("piros","kék","zöld","sárga"); $hossz print $hossz; A program kiír egy 4-est, mivel létrehoztunk tömböt, mely négy sztringet tartalmazott, majd a $hossz értékének -et adtuk meg, így az $hossz a tömb elemeinek számát, a 4-est kapta értékül, mely a következő sorban kiírásra került. Lehetőségünk nyílik u.n. tömbszeletek kezelésére is, ezzel a tömbnek egy részére hivatkozhatunk, az alábbi módon: @szinek = ("piros","kék","zöld","sárga"); $szelet print $szelet; Ekkor kiírásra kerül, hogy zöldsárga, mivel ez volt a tömb 3. és 4. eleme. Ezzel könnyedén felcserélhetünk két tömbelemet, nem kell külön skalár változót bevonni, amiben ideiglenesen tárolásra kerülne az egyik elem, az egész egy sorral megoldható: @szinek[1,2]

11 Push, pop, shift, unshift operátor
Segítségükkel a tömb végét alakíthatjuk anélkül, hogy tudnánk a tömb hosszát. A push használatával a tömb végéhez lehet csatolni további eleme(ke)t, a pop épp ezzel ellentétes, a tömb utolsó elemét lehet vele eltávolítani. Nézzünk erre egy példát! @szinek = ("piros","kék","zöld","sárga"); $szin = "lila"; $utolsoszin = Először létrehoztunk egy négyelemű tömböt majd egy skalárt ($szin), melynek a lila értéket adtuk. Aztán hozzácsatoltuk a $szin-t, és még egy sztringet, mely a narancs, és tömb 4. elemének az összetételéből következett, azaz a narancsból, és a sárgából. Itt is használható egyszerű skalár éppúgy, mint sztring, vagy akár ezek kombinációja. Tehát ekkor a tömbünk elemei a következők: piros, kék, zöld, sárga, lila, narancssárga. Végül a tömb utolsó elemét levágjuk, és egy változóban tároljuk.

12 Revese A reverse használatával a tömb elemeinek sorrendjét felcserélhetjük. Ez az operátor nem írja felül az eredeti tömböt, ezért egy másikat kell létrehozni, amely ugyan azokat az elemeket fogja tartalmazni, mint az eredeti, csak fordított sorrendben (hivatkozhatunk az eredeti tömbre is, ekkor felülírja). Lássunk erre is egy példát! @szamok = (1,2,3,4,5); @visszafele = Ekkor elemei a következők lesznek: 5, 4, 3, 2, 1. Ha számokból álló tömböt hozunk létre, ezzel lerövidíthetjük a létrehozást: @szamok = (1..5); Ezzel ugyan azt értük el, mint a fenti formával, azaz a tömb elemei a következők lettek: 1, 2, 3, 4, 5. Ez használható betűknél is (a-z).

13 Sort Ezzel egy tömb tartalmát rendezhetjük:
@szinek = ("piros","kék","zöld","sárga"); @szinek = Mint látható, ez sem írja felül az eredeti tömböt, így ha felül szeretnénk írni, akkor önmagára kell hivatkoznunk. A sort hatására tartalma a következő lett: kék, piros, sárga, zöld. @szamok = (12,5,437,9,28); @szamok = Ekkor tartalma: 12, 28, 437, 5, 9. De vajon miért? Mert a rendezés karakterenként történik, a számokat ugyanúgy rendezi, mintha szöveg lenne, azaz először az első számjegy alapján állítja őket sorrendbe, majd ha van egyező, azoknál kezdi el vizsgálni a második számjegyet.

14 Hash A hash (más néven asszociatív tömb) abban hasonlít a fent tárgyalt tömbhöz, hogy ebben is skalárok tárolására van lehetőség, azonban itt az indexelés nem számokkal, hanem sztringekkel történik, azaz itt egy tömbelemre nem a száma, hanem a neve szerint hivatkozunk (tehát létrehozáskor ezt is meg kell adni). Nézzünk egy példát hash létrehozására! %sokminden = ("szín","piros","hónap","június","virág","rózsa"); Ez így elég nehezen nyomon követhető, ezért van egy másik forma is, a magyarázat előtt nézzük meg azt: %sokminden = ( "szin" => "piros", "honap" => "június", "virag" => "rózsa" ); Tehát, mint látható, létrehoztunk egy %sokminden nevű asszociatív tömböt, melynek három elemet adtunk: szín, hónap, virág, és ezeknek adtunk értéket is, piros, június, rózsa. Az egyes elemekre való hivatkozás itt is egyszerű skalárként történik, a kívánt elem nevének kapcsos zárójelbe való írásával: print $sokminden{"honap"}; A program kiírja, hogy június, mivel fent ezt adtuk meg.

15 Hash Természetesen ez a forma használható új tömb létrehozására, már meglévő elemek módosítására, és új elem behozatalára is: %sokminden = ( "szin" => "piros", "honap" => "június" ); $allatok{"madar"} = "papagáj"; $allatok{"kutya"} = "huski"; $nev = "madar"; $sokminden{"kutya"} = $allatok{"kutya"}; $sokminden{$nev} = $allatok{"madar"}; $sokminden{"szin"} = "sárga"; Először létrehoztunk egy %sokminden nevű tömböt, mely két elemet kapott, a szin-t és a honap-ot. Aztán egy %allatok tömb került létrehozásra, azonban ez a hivatkozási formával, először kapott egy madar, majd egy kutya elemet. Aztán létrehoztunk egy egyszerű skalárt ($nev). Ez után a %sokminden tömbhöz létrehoztunk egy új elemet, melynek a neve kutya lett, ehhez rendeltük értéknek a %allatok tömb kutya nevű értékét. Aztán a %sokminden-t újabb elemmel bővítettük, melynek neve az $nev változó tartalma lett, értéke pedig a %allatok tömb madar értéke lett. Végül a %sokminden szin nevű paraméterét változtattuk meg sárgá-ra. Tehát a %sokminden tartalma most: szin=>sárga, honap=>június, kutya=>huski, madar=>papagáj.

16 Keys Ennek használatával a tömbben lévő kulcsokat kaphatjuk meg. Itt egy példa: %sokminden = ( "virag" => "rózsa", "szin" => "piros", "honap" => "június"); print keys(%sokminden); Kiírja, hogy viragszinhonap. Ennek később, a ciklusoknál fogjuk sok hasznát venni, ha egy hash összes elemén végig akarunk menni. Ha a keys operátort hozzárendelésnél használjuk, akkor a kulcsok számát adja vissza: %sokminden = ( "szin" => "piros", "honap" => "június", "virag" => "rózsa" ); $hossz = keys(%sokminden); print $hossz; #kiírja, hogy 3

17 Values A values operátor hasonló, csak ez nem a kulcsokat, hanem az értékeket adja vissza: %sokminden = ( "virag" => "rózsa", "szin" => "piros", "honap" => "június" ); print values(%sokminden); Kiíródik a következő karaktersorozat: rózsapirosjúnius. A hozzárendelést egy tömbhöz is végezhetjük: %sokminden = ( "virag" => "rózsa", "szin" => "piros", "honap" => "június" ); @ertekek = values(%sokminden); print $ertekek[1]; Mint látható, az értékeket egy tömbben tároltuk, majd kiírattuk a tömb második elemét, azaz a június-t.

18 Delete A delete operátor, meglepő módon törlésre használható:
%sokminden = ( "virag" => "rózsa", "szin" => "piros", "honap" => "június" ); delete $sokminden{honap}; %sokminden tartalma: virag=>rózsa, szin=>piros lesz.

19 Szubrutinok Az alprogramok jele a &, tehát meghívásnál ezt kell alkalmazni. Deklarációnál (tehát ott, ahol leírjuk, hogy mit is csináljon a szubrutin) a sub-ot kell használni. &alma; exit; sub alma { print "Ezt az üzenetet az alma nevű szubrutin írta ki."; } Mint látható, először meghívtuk az alprogramot. Aztán egy exit utasítás következett, ez a programból való kilépésre, vagy a program megszakítására szolgál. Aztán következett maga a deklaráció, melyet egy sub utasítás kiadásával lehet elkezdeni, ezt az alprogram neve (ahogy hivatkoztunk rá) követi, majd egy utasításblokk, Tehát egy { majd az utasítások felsorolása, végül egy }. Ilyen utasításblokkokat még sok helyen fogunk használni. A blokkon belül nem szükséges a sorok elé szóközöket vagy tabulátorokat tenni, ez csak az áttekinthetőséget javítja (hosszabb programok esetén érdemes használni).

20 Szubrutinok Alprogramoknál használatos a return utasítás, mellyel visszatérési értéket adhatunk meg: $udvozlet = &alma; print "$udvozlet\n"; exit; sub alma { $szoveg = "Helló!"; return $szoveg; } Itt az alma szubrutinban egy $szoveg változóba tároltunk egy sztringet, a hivatkozáskor pedig az egész alprogramot egy változóhoz rendeltük hozzá, majd kiírattuk. Természetesen lehetőség van adatok átvitelére is, ezeket a hivatkozáskor kell megadni, majd az alprogramban elemeiként kapjuk meg őket: &udvozlet("Helló","Minta Péter"); exit; sub udvozlet { print "$_[0], az én nevem $_[1].\n"; } A hivatkozásnál két paramétert adtunk meg, két sztringet. Az alprogramban pedig a két adat felhasználásával egy üdvözlő szöveget írtunk ki, feltételezve, hogy az első adat egy köszönési forma, a második pedig egy név.

21 Szubrutinok @elemek = ("könyv","telefon","internet","magazin"); exit; sub utolso { $utolso = pop; print "Az utolsó elem: $utolso\n"; } A program kiírja, hogy magazin. De miért? Először létrehoztunk egy tömböt majd hivatkoztunk az alprogramra, tömb tagjait megadva paraméterként. A szubrutinban pedig egy változóban tároltuk az átadott elemeket tartalmazó tömb utolsó elemét. Ami érdekes, hogy nevet meg sem említettük, a pop operátort paraméter nélkül használtuk. Ez azért van, mert mindig az _ nevű adattípus az alapértelmezett, tehát ha valahol nem adok meg semmit, akkor ezt fogja használni.

22 Értékadó/aritmikai operátorok
$szam = 10; $szam += 4; #$szam értéke 14 lesz $szam -= 5; #$szam értéke 9 lesz $szam *= 2; #$szam értéke 18 lesz $szam /= 3; #$szam értéke 6 lesz $szam .= " db alma"; Amint látható, egy $szam változót hoztunk létre, majd különböző műveleteket hajtottunk vele végre.

23 Értékadó/aritmikai operátorok
$a = 10; $b = 2; $c = $a * $b; #$c értéke 20 $d = 2 * 5; #$d értéke 10 $d += $b * $c; #$d értéke növekszik (2*20) –al, tehát 50 lesz print $d - $b; #kiírja, hogy 48 Mint látható, létrehoztunk két változót, majd egy harmadikba a kettőt összeszoroztuk. Aztán egy negyedik változóba két számot szoroztunk össze, utána pedig növeltük az értékét az első két szám szorzatával, végül levontuk belőle $b értékét, és az eredményt kiírtuk. Utóbbi két műveletet egy sorban is el lehet végezni.

24 Értékadó/aritmikai operátorok
Most pedig nézzünk meg még két operátort, a maradékképzőt és a négyzetre emelőt: print 10 % 3; #kiírja, hogy 1 print 8 % 3; #kiírja, hogy 2 print 2**2; #kiírja, hogy 4 print 5**2; #kiírja, hogy 25 Mint látja, a % operátor maradékot képez, hatványozásra pedig a ** szolgál. Most nézzünk meg egy érdekesebb példát! print -4 ** 2; #kiírja, hogy -16 Ez vajon hogy lehet, hiszen –4 a négyzeten, az 16? – vetődik fel a kérdés. A válasz egyszerű, a Perl a hatványozást magasabb rendű műveletként kezeli, ezért előbb elvégzi, és utána teszi ki az előjelet.

25 Aritmikai operátorok $x = -4; print $x**2; #kiírja, hogy 16
Itt először eltároltuk a negatív számot egy változóba, majd a változót hatványoztuk, a kimenetre így már 16 kerül. A Perl külön operátorokkal rendelkezik az inkrementáláshoz és a dekrementáláshoz, ez a ++ és a --. Mindkettő tehető a változó elé és mögé is, a különbség az, hogy ha a változó előtt van, akkor az értéket előbb növeli/csökkenti, és a visszatérési érték már az új érték lesz, viszont ha a változó mögött van, akkor a visszatérési érték az eredeti érték lesz, és csak ez után fogja növelni az értéket. Nézzünk egy példát! $a = 1; $b = ++$a; print "\$a értéke: $a\n\$b értéke: $b\n"; A kimenetre ez kerül: $a értéke: 2 $b értéke: 2

26 Aritmikai operátorok Most nézzük meg ugyanezt, ha a ++ a változó mögött van: $a = 1; $b = $a++; print "\$a értéke: $a\n\$b értéke: $b\n"; A kimenetre ez kerül: $a értéke: 2 $b értéke: 1 A különbség egyértelmu, az elso példában az $a értékét eloször növelte, ezért a visszatérési érték már 2, a másodikban viszont csak utána, ezért a visszatérési érték még 1 volt. Ugyan ez a helyzet a -- -nál is.

27 Aritmikai operátorok Az ismétlő operátor (x) egy sztringet sokszoroz meg az alábbi módon: print "-" x 10; #kiírja, hogy Az ismétlés operátorral tömböket is hozhatunk létre, ekkor zárójelekkel kell ezt jelölni: @tomb = ("-") x 5; print $tomb[2]; Itt egy 5 elemu tömb került létrehozásra, melynek minden eleme egy - karakter, majd kiírtuk a tömb 3. elemét.

28 Összehasonlító operátorok
> (nagyobb, mint) < (kisebb, mint) >= (nagyobb vagy egyenlő) <= (kisebb, vagy egyenlő) != (nem egyenlő) <=> (összehasonlítás) Amikor két adatot összehasonlítunk, és az összehasonlítás igaz, akkor a Perl egy 1-est fog visszaadni, ha nem igaz, akkor nullsztringet. Kivétel az összehasonlítás, ahol ha nagyobb, akkor 1-et ad vissza, ha kisebb, akkor –1-et, ha egyenlő, akkor 0-át. Tekintsünk meg néhány példát! $igaz = (4 != 3); $hamis = (10 < 10); print $igaz; #kimenet: 1 print $hamis; #nincs kimenet print (2 > 1); #kimenet: 1 print (4 <= 4); #kimenet: 1 print (1 >= 3); #nincs kimenet print (4 <=> 3); #kimenet: 1 print (4 <=> 4); #kimenet: 0 print (4 <=> 5); #kimenet: -1

29 Összehasonlító operátorok
A összehasonlító operátoroknak létezik egy másik változata is, melyet sztringek összehasonlításánál használunk: eq (egyenlő) ne (nem egyenlő) gt (nagyobb, mint) lt (kisebb, mint) ge (nagyobb, vagy egyenlő) le (kisebb vagy egyenlő) cmp (összehasonlítás)

30 Logikai operátorok and, or, not - &&, ||, ! aki már jártasabb egy kicsit ezen a téren, az már biztosan találkozott velük. Több kifejezést lehet segítségükkel vizsgálni, az and akkor tér vissza igaz értékkel, ha mindkét feltétel igaz, az or a bal oldalival ha igaz, ha nem, akkor a jobbal, a not pedig igazzal tér vissza, ha mindkét kifejezés hamis: print (5 > 1) && (10 > 9); #kimenet: 0 A kimenet 0, vagyis true, mert mindkét állítás igaz. Viszont az alábbi példa már nem fog kiírni semmit (false): print (5 < 1) && (10 > 9); #kimenet: 1 Mint látható, az && operátornál elég, ha csak az egyik kifejezés hamis, a visszatérési érték már false lesz.

31 Vezérlési szerkezetek, elágazások
A vezérlési szerkezetek általában egy feltételből, és egy utasításblokkból állnak. A feltétel feladata, hogy az utasításblokkot a feltétel logikai értékének megfelelően hajtsa végre. Mi is az az utasításblokk? Egy { és } –el elhatárolt programrész, melyekben tetszőleges számú utasítás található. Az egyik leggyakrabban használt vezérlési szerkezet az if/elseif/else. Nézzünk egy egyszerű példát az if használatára! $a = 1; $b = 3; if ($a < $b) { print 'Az $a változó értéke nagyobb, mint az $b-é.'; } Két skalár került létrehozásra ($a, $b), majd egy elágazás következett, melyben megvizsgáltuk, hogy az $a értéke nagyobb-e, mint az $b értéke, és ha ez igaz volt, akkor kiírattunk egy sztriget. Nézzük meg a fenti példát az else utasítással kibővítve. Az else után következő utasításblokk akkor hajtódik végre, ha az if után következő feltétel nem igaz. $a = 1; $b = 3; if ($a == $b) { print 'Az $a változó értéke egyenlő az $b-ével.'; } else { print 'A feltétel nem igaz!!'; }

32 Elágazások Mivel nem egyenlők, “A feltétel nem igaz" sztring került kiírásra. Az if-nek az else-en kívül van még egy párja, az elseif mely az else-hez hasonlóan akkor hajtódik végre, ha az if nem igaz, viszont további feltételt szab meg. Az elseif után következhet mégegy else is: $a = 1; $b = 3; if ($a == $b) { print 'Az $a változó értéke egyenlô az $b-ével.'; } elseif ($a > $b) { print 'Az $a változó értéke nagyobb, mint az $b-é.'; } else { print 'Az $b változó értéke nagyobb, mint az $a-é.'; }

33 Elágazások Van egy másik elágazásfajta is, ez az unless, mely nagyon hasonló az if-hez, különbség csak abban van, hogy míg az if használatánál a feltétel utáni utasításblokk akkor került végrehajtásra, ha a feltétel igaz volt, itt épp ellenkezőleg, akkor kerül végrehajtásra, ha a feltétel hamis: $a = 10; $b = 2; unless ($a < $b) { print '$a nagyobb, mint $b'; } else { print '$b nagyobb, mint $a'; }

34 rand, int Az első függvény a rand, mely egy random (véletlenszeru) számot fog visszaadni, 0 és az első paraméter értéke között (a paramétert az előző számban tárgyalt szubrutinok meghívásánál megismert módszer szerint adhatja meg). Ha nem adunk meg paramétert, akkor a szám 0 és 1 között lesz. Nézzünk egy példát! $szam = rand(5); print "Véletlenszeru szám: $szam"; A kimenetre ez kerül: Véletlenszeru szám: Persze ez a szám minden futtatáskor más (nagyon kicsi annak az esélye, hogy ugyanazt az értéket írja ki). Mint látható, egy tört számot ad vissza a függvény (általában), ezért ajánlott az int függvény használata, mely egy számnak veszi az egész részét: $szam = ; print int($szam); #kiírja, hogy 6

35 Példa Most pedig készítsünk el egy programot, amelynek egy fiktív háromszög oldalainak hosszát megadva megmondja, hogy a háromszög derékszögű-e. Ehhez a Pitagorasz-tételt fogjuk alkalmazni, azaz derékszögű háromszögben a2+b2=c2. print "Add meg egy háromszög három oldalának a hosszát egységekben!\n"; #adatok felvétele (a három oldal: $a, $b, $c) print "Az elsô oldal: "; chomp($a = ); print "A második oldal: "; chomp($b = ); print "A harmadik oldal: "; chomp($c = ); #adatok vizsgálata (a^2 + b^2 = c^2 ?) if ( $a**2 + $b**2 == $c**2) { #ha igaz print "Ez egy derékszögu háromszög!"; } else { #ha hamis print "Ez sajnos nem derékszögu háromszög!"; }

36 Ciklusok Tekintsük meg az első fajtáját a ciklusoknak, a while utasítást. Arra szolgál, hogy amíg a kifejezés logikai értéke igaz, addig mindig végrehajtja az utasításblokkot, ha a kifejezés hamissá válik, a program futása az utasításblokkot lezáró } után folytatódik. Tekintsen meg egy egyszerű példát! $a = 3; $b = 10; while ($a < $b) { $a++; } Két skalár került létrehozásra, $a és $b. Ezután egy while ciklus addig ismételgetett egy utasításblokkot, amíg $a értéke nem lett nagyobb $b-nél, az utasításblokkban pedig $a értéke került növelésre. Akkor hogyan is zajlott le a program lefutása? Mivel $a értéke 3, $b pedig 10, ezért az $a < $b feltétel igaznak bizonyult. Ekkor a program lefutatta az utasításblokkot, melyben $a értéke növelésre került eggyel, így az értéke már 4 volt. Azonban ez még mindig kisebb, mint az $b értéke, tehát megint lefutott az utasításblokk. És ez így ment mindaddig, amíg $a értéke el nem érte a 10-et, akkor ugyanis még egyszer lefutott az utasításblokk (tehát ha a program végén kiírattuk volna $a értékét, akkor 10-et írt volna ki), és itt lett vége.

37 until A while „testvére” az until, mely ugyanazt csinálja, mint a while, annyi különbséggel, hogy az utasításblokkot addig ismételgeti, amíg a feltétel igazzá válik. Tekintsük meg az előző példát az until használatával! $a = 3; $b = 10; until ($a >= $b) { $a++; } Az eredmény ugyanaz lesz, mint az előző példánál. Azonban itt a relációjel megfordításán kívül egy = jel is bekerült, mivel ha az nem lenne, és szigorúan nagyobbnak kellene lenni a $a-nak a $b-nél, akkor a ciklus után az $a a 11 értéket kapná, mivel ha a két változó már egyenlő lenne egymással, még akkor sem lenne a kifejezés értéke igaz (true).

38 do .. while, do .. until A while és az until párja a do.…while és a do…until. Ezek a szerkezetek valójában nem léteznek Perl-ben, azonban egy do függvény segítségével előállíthatók, akkor használjuk őket, ha azt szeretnénk, hogy az utasításblokk végrehajtásra kerüljön, mielőtt a kifejezés kiértékelése megtörténne. Tekintsünk meg egy példát! $szam = 0; do { $szam++; print "$szam;"; } while ($szam < 10); A kimenet az alábbi lesz: 1;2;3;4;5;6;7;8;9;10; Az $szam skalár a 0 értéket kapta, majd az utasításblokkban az értéke növelésre, majd kiírásra került mindaddig, amíg az értéke kisebb volt, mint tíz (mivel a kiértékelés a végrehajtás után történik, még a 10-es is kiírásra kerül). A do…until-al a fenti példa az alábbi módon oldható meg: $szam = 0; do { $szam++; print "$szam;"; } until ($szam >= 10); A kimenet ugyan az lesz, mint a fenti példánál. A >= operátorra azért volt szükség, hogy a kiértékelés igazzá váljon, ha az $szam a 10-es értéket kapja, mert ellenkező esetben a 11-es is kiírásra kerülne.

39 do .. while, do .. until, for Töltsünk fel egy tömböt számokkal, a do…while segítségével! $szam = 0; do { $szam++; } until ($szam >= 10); tartalma: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. A következő ciklusszerkezet az egyik leggyakrabban használt, és egyben a legösszetettebb, a for ciklus. A szintaktikája valahogy így néz ki: for (kezdeti érték; ellenőrzés; érték megváltoztatása) { utasításblokk } A kezdeti értékben egy változónak egy alapértéket adunk meg, majd az ellenőrzésnél egy kifejezést készítünk, melyben ezt a változót vizsgáljuk, ez után pedig a változó értékét módosíthatjuk.

40 for A ciklus futása ezek után úgy fog kinézni, hogy létrehozza a változót a kezdeti értékkel, majd azt megvizsgálja a kifejezésben megadottak szerint, és ha a kifejezés nem igaz, akkor lefut az utasításblokk, és elvégzi a változtatást a változón, majd újra ellenorzi, és ha így már igaz a kifejezés, akkor továbblép, és folytatja a futást a for ciklus után, ha még mindig nem igaz, akkor újból végrehajtja a változtatásokat, és így tovább. Tekintsünk meg egy egyszerű példát! for ($x=0; $x<10; $x++) { print "$x\n"; } Ez a ciklus kiírja az egész számokat 0-9-ig, egymás alá. Egy másik példa, mely ugyanazt csinálja, mint a fenti, csak csökkenő sorrendben írja ki a számokat: for ($x=9; $x>=0; $x--) { print "$x\n"; } A kimenetre egymás alá kerülnek a számok, 9-0-ig. Az $x kezdeti értékként a 9-et kapta, majd a vizsgálatnál az operátor “nagyobb, vagy egyenlő” volt, mivel ha csak “nagyobb” lett volna, akkor a 0 kimaradt volna a számsorból (ebben az esetben –1-et kellett volna írni a 0 helyére, így már 0-ig ment volna a számsor).

41 for For ciklus segítségével kiírathatjuk egy tömb összes elemét:
@tomb = ("monitor","egér","nyomtató","billentyűzet"); for ($x=0; $x++) { print "$x. elem: $tomb[$x]\n"; } A kimenetre az alábbiak kerülnek: 0. elem: monitor 1. elem: egér 2. elem: nyomtató 3. elem: billentyűzet

42 foreach A for ciklus másik fajtája a foreach ciklus, mely egy értéklistán megy végig, például egy tömbön, és minden értéket egy változóba másol. Tekintsük meg egy, az előzőhöz hasonló példát a foreach ciklus használatával! @tomb = ("monitor","egér","nyomtató","billentyűzet"); print "A tömb elemei:"; foreach $elem { print " $elem;"; } A kimenetre pedig az alábbi sor kerül: A tömb elemei: monitor; egér; nyomtató; billentyűzet;

43 foreach Az alábbi példa egy Hash elemeit listázza ki: %sokminden = ("gyümölcs" => "alma", "virág" => "rózsa", "madár" => "gólya"); foreach $kulcs (keys %sokminden) { print "$kulcs: $sokminden{$kulcs}\n"; } És a kimenet: virág: rózsa gyümölcs: alma madár: gólya

44 redo A redo operátor, mellyel a kifejezéstől függetlenül még egyszer végrehajtódik az utasításblokk. Tekintsünk meg egy példát! @szamok = (1..10); foreach $szam { $szam++; if ($szam < 20) { redo; } print "$szam "; } Itt egy tömböt hoztunk létre, melynek elemei 1, 2, 3, … 9, 10 – a tartományoperátort használtuk, melyről már volt szó. Aztán egy foreach ciklussal mentünk végig az értékeken, és mindet növeltük eggyel. Aztán megvizsgáltuk, és ha értéke kisebb volt, mint 20, akkor a redo segítségével itt megszakítottuk az utasításblokkot, és elölről kezdtük, tehát, megint növeltük az értéket. Ha az érték már 20 volt, akkor az if elágazásban a kifejezés már nem volt igaz ($x < 20), ezért az érték kiírásra került. Ez a folyamat zajlódott le az összes tömbelemnél, így tíz db 20-as került a kimenetre.

45 redo A redo segítségével ciklusokat is készíthetünk egyszerű utasításblokkokból: $szam = 1; { if ($szam < 10) { $szam++; redo; } } print "\$szam értéke: $szam"; Egy utasításblokkot készítettünk, melyben megvizsgáltuk $szam értékét, és ha kisebb volt, mint 10, akkor növeltük az értékét, és újra végrehajtattuk az utasításblokkot. A kimenetre ez került: $szam értéke: 10

46 next Ez az operátor arra való, hogy az utasításblokk végrehajtását megszakítsuk, és azonnal a következő ciklusra ugorjunk. Nézzünk meg egy ciklusszerkezetet, mely felsorolja egy tömb elemeit, kivéve a második elemet: @tomb = ("processzor","alaplap","memória","háttértár","meghajtó"); for ($x=0; $x++) { if ($x eq 1) { next; } print "$tomb[$x]\n"; } A kimenet: processzor memória háttértár meghajtó Mint látható, a tömb elemei felsorolásra kerültek, kivéve a második elemet, mivel ha az aktuális tömbelem számozása 1 volt, akkor a next utasítás hajtódott végre, ergo kimaradt a tömbelemet kiíró sor.

47 last A last operátor hasonló a next-hez, mivel itt is ugyanúgy megszakítja az utasításblokk végrehajtását, csak itt nem a következő ciklusra ugrasztja, hanem teljesen kilépteti a ciklusszerkezetből a program futását. Tekintsük meg a fenti példát a last használatával! @tomb = ("processzor","alaplap","memória","háttértár","meghajtó"); for ($x=0; $x++) { if ($x eq 1) { last; } print "$tomb[$x]\n"; } És a kimenet pedig: processzor A program futása hasonlóképpen zajlott az előzőhöz, viszont itt a második elem átugrása után végleg elhagyta a ciklusszerkezetet.

48 Helyettesítés Helyettesítések segítségével egy mintát kereshetünk egy sztringben, találat esetén pedig a mintát egy másikra cserélhetjük. Egy egyszerű példa: $betuk = "abcd"; $betuk =~ s/a/b/; print $betuk; A program a skalárban az “a” betűt b-re cserélte, a helyettesítés szintaktikája tehát: s/helyettesítendő minta/mire cserélje/ Ezek után nem meglepő, hogy a kimenetre “bbcd” kerül. Mivel itt is mintaillesztésről van szó, használhatók a múlt számban ismertetett mintaillesztésnél használatos operátorok is, az alábbi program például a sztringben lévő számot és az előtte szereplő karaktert felcseréli: $sztring = "abcde9fgh"; $sztring =~ s/(.)([0-9])/$2$1/; print $sztring; A program kiírja, hogy abcd9efgh. A mintánál egy tetszőleges karaktert adtam meg, melyet egy szám követ, persze mind a kettőt zárójelek között, így a talált karakterek eltárolódtak a $1 és a $2 változóba, így a helyettesítő sztring helyére csak ezt a két változót adtam meg felcserélve ($1$2).

49 Helyettesítés $a = "haaaaaah"; $a =~ s/a{3,}/i/; print $a; $b = "haaaaaah"; $b =~ s/a{3,4}/i/; print $b; $a és $b értékében hatszor szerepel egymás után az a betű. Először egy mintaillesztést hajtunk végre, amelyben ha háromszor, vagy többször szerepel az “a”, akkor lecseréljük azokat egy “i”-re. Ekkor a program kiírta, hogy hih, mivel nem adtunk meg maximális értéket a keresendő a betűk számának a megadásakor. Másodjára, $b eseténél viszont már megadtam maximális értéknek a 4-et, így a kimenetre az került, hogy “hiaah”, mert az illesztés maximum 4 db a betűre vonatkozik. A következő példa a szavak közti szóközök számát egyre csökkenti, amennyiben több is megtalálható: $a = "több szóköz a szavak között"; $a =~ s/ +/ /g; print $a; A sokszorozót (ez esetben a + jelet, de lehetett volna {1,} vagy {2,} is) ez esetben egy szóköz után tettük, így a program az egyszer, vagy egynél többször szereplő szóközöket kereste. A kimenet: több szóköz a szavak között

50 Helyettesítés Az alábbi opciók használhatók a helyettesítő operátornál: g – többször is illeszt i – nem különbözteti meg a kis és a nagybetűket Egy példa: $a = "haaaaaa"; $a =~ s/a/i/; print $a; $b = "haaaaaa"; $b =~ s/a/i/g; print $b; A kimenetre először az kerül, hogy hiaaaaa, másodjára az, hogy hiiiiii. Mint látható, alapértelmezésben a Perl csak egyszer végzi el az illesztést, azonban a g opció használatával már az összes “a” betűt lecserélte. Példa az i használatára: $a = "kisbetuNAGYBETU"; $a =~ s/un/u_N/; print $a; $b = "kisbetuNAGYBETU"; $b =~ s/un/u_N/i; print $b; Ebben az esetben $a és $b olyan értéket kapott, amelyben szerepel kis- és NAGY betu is. Az elo esetben csak a szokásos módon hajtottuk végre a cserét, ezért a minta nem volt illeszthető, mivel a Perl különbséget tesz a kis- és a nagy betűk között [Az “un” nem egyenértékű “uN” -el], ezért a kimenetre “kisbetuNAGYBETU” került. A második esetben, az i funkció használatával a Perl már egyenértékűnek vette az “un”-t az “uN” –el, így végrehajtotta az illesztést, a kimenetre itt már “kisbetu_NAGYBETU” került.

51 split $gymumolcsok = "alma;narancs;barack;meggy;ananász"; ($a, $b, $c, $d, $e) = split(/;/, $gymumolcsok); print "$b"; Egy skalár került létrehozásra különböző szavakat tartalmazva, melyek egy ;-vel voltak elválasztva. Ez után következett a szóban forgó split operátor használata, először a változók neveit kell megadni, amelyekbe az egyes elemek eltárolódnak, majd ezeknek értékként a split-et adni, melyben először a mintát kell leírni, majd a szétvagdosni kívánt változót. Ekkor a felsorolt változókba fognak kerülni a szétvagdosásnál keletkezett darabok. $gymumolcsok = "alma;narancs;barack;meggy;ananász"; = split(/;/, $gymumolcsok); print $gyumolcsok[1]; A kimenet szintén a "narancs".

52 join a join hasonlóan muködik, mint a split, csak épp az ellentétét csinálja, a megadott minta alapján sztringeket fűz össze. Bővítsük ki az előzői példát a join-al! $gymumolcsok = "alma;narancs;barack;meggy;ananász"; ($a, $b, $c, $d, $e) = split(/;/, $gymumolcsok); $egybefuzve = join(', ', $a, $b, $c, $d, $e); print $egybefuzve; Ami ezt írja ki: alma, narancs, barack, meggy, ananász Mint látja, a join operátornak először meg kell adni, hogy mit írjon a változók tartalmai közzé, majd felsorolni a változókat, amelyeket egybe kíván fűzni. Persze a fenti példát sokkal egyszerűbben megoldhattuk volna egy cserével. :) Nem csak változókat, hanem egy, vagy akár több tömb elemeit is egybefűzhetjük: @a = ("virág","ház","autó"); @b = ("madár","újság"); $egybefuzve = print $egybefuzve; A fenti kódrészlet az alábbiakat írja ki: virág, ház, autó, madár, újság

53 stdin $szoveg_a = "A mondat után sortörés van.\n"; print $szoveg_a . "[vége]"; print "\n"x3; $szoveg_b = "A mondat után sortörés van, melyet levágunk.\n"; chomp($szoveg_b); print $szoveg_b . "[vége]"; Mint látható, létrehoztunk egy sztringet, melyet sortörés zár, majd kiírtuk, a végén egy "[vége]" felirattal. Aztán megismételtük ugyanezt, csak a kiírás előtt a chomp-al levágtuk a sortörést, így a kódrészlet kimenete: A mondat után sortörés van. [vége] A mondat után sortörés van, melyet levágunk. [vége] Jól látható, hogy az első résznél a “[vége]” már a következő sorba került, ezzel ellentétben a második esetben még ugyanabba a sorba írta ki. E kis kitérő után folytatnám a standard bemenet ismertetését. Tekintsen meg egy programot, mely mindaddig adatokat olvas be, amíg a felhasználó be nem írja, hogy “vege”: while ($adatok = ) { if ($adatok eq "vege\n") { last; } else { $osszes_adat .= $adatok; } }

54 stdin $filenevek = join(', print $filenevek; Hívjuk meg a programot az alábbi módon! perl pelda-2.pl elso.txt masodik.txt harmadik.txt Melynek hatására az kiírja: elso.txt, masodik.txt, harmadik.txt A példa megtalálható mellékelve, pelda-2.pl néven. tömb akár meg is változtatható, így anélkül is olvashatunk be file-okat, hogy a futtatáskor megadnánk a filenevet. Persze file-ok beolvasására általában nem ezt a módszert használjuk, a filekezelés a következo rész témája lesz.

55 stdout print "Helló Világ!\n"; print STDOUT "Helló Világ!\n";
Ha hosszabb, több sortörést tartalmazó szövegeket jelenítünk meg, akkor használható az alábbi forma: print < Több soros szöveg, levédés nélkül használhatók "idézôjelek", használata egyszer?bb. VEGE Mint látható, a print után két < jelet követően egy szöveget kell megadni [pontosvessző zárja a sort itt is]. Az itt megadott szöveget kell majd még egyszer megadnunk, ez fogja a Perl-nek a megjelenítés végét jelezni. A kimenetre a szöveg kerül, sortörésekkel együtt. Mint az a példában is olvasható, nem kell bajlódnunk a ' és " karakterek levédésével, azonban a tömbök illetve változók beszúrása itt is megtörténik, ezért a és % karakterekkel már óvatosan kell bánni. Ha a megjelenítést lezáró tagnak [ebben az esetben a "VEGE"] önállóan kell szerepelnie egy sorban, különben a megjelenítés nem fog lezáródni, és természetesen a megjelenítendő szövegben sehol sem szabad szerepelnie önállóan egy sorban. Néhány példa: print < Ez a mondat tartalmazza a VEGE szót külön sorban, ezért hibaüzenet fogunk kapni... VEGE print < Ez a mondat viszont rendben meg fog jelenni, mert a VEGE szó nem önálló sorban van. VEGE print < A lezáró tag után nem kell pontosvessző, mert probléma lesz belőle... VEGE; print < Ebből is probléma lesz... VEGE

56 Formázott kiírás Végül a megformázott kimenetről ejtenék néhány szót. Ebben az esetben a kiírásnál a print helyett a printf függvényt használjuk, melynek két paramétert kell megadni, a formázó utasításokat, valamint magát a kimenetet. A formázó utasításban két dolgot határozunk meg, először a kimenet típusát [pl. sztring, lebegőpontos szám, stb.], majd a mező méretét, amelyben a sztring kiírásra kerül [ergo a sztring szóközökkel töltődik fel, így éri el a kívánt hosszt]. Az egyszerű sztring jele az s, az alábbi példában egy 10 karakter hosszú kimenetet fogunk készíteni egy sztringbol: printf "%10s", "szöveg"; A kimenet ez lesz: szöveg Mint látható, a skalár tartalmának hossza rövidebb volt, mint a formázásnál megadott szám, így szóközökkel feltöltésre került. Ha a hossz nagyobb vagy egyenlő, mint a megadott szám, akkor a fent látott formázásnak nem lesz hatása, mivel a Perl automatikusan beállítja a megfelelő értéket: printf "%10s", "hosszabb szöveg"; A kimenet: hosszabb szöveg

57 Formázott kiírás Számokat a d segítségével írunk ki: @szamok = (3,54,436.43, ,3.4,986.1); foreach $szam { printf "%5d", $szam; print "\n"; } Ebben az esetben a kimenet: Mint látható, a nem egész számoknál a tizedespont utáni rész nem került kiírásra.

58 Formázott kiírás Azonban a fenti példa az f segítségével már máshogy mutat [ebben az esetben meg kell adni a tizedesjegyeknek szánt hely hosszát is]: @szamok = (3,54,436.43, ,3.4,986.1); foreach $szam { printf "%8.3f", $szam; print "\n"; } A kimenet így már pontos, és igen rendezett, mivel az f használatakor a Perl a tizedespontokat egy vonalba rendezi: A példában a hossznál megadott 8.3 számból a 8-as a kiírt sztring egészére érvényes, melyből a tizedespont utáni számjegyek kapják majd a 3 karakter hosszúságú mezot. Azonban ez mindenképpen 3 karakter marad, akárhány számjegyből áll a szám, a Perl itt már nem fogja meghosszabbítani a mezőt: @szamok = ( , , , , ); foreach $szam { printf "%8.3f", $szam; print "\n"; } A kimeneten a számok tizedesjegyeinek a száma 3-ra korlátozódik:

59 Formázott kiírás Akár exponenciális számokat is képezhetünk, az e segítségével: @szamok = (3,54,436.43, ,3.4,986.1); foreach $szam { printf "%8.3e", $szam; print "\n"; } A kimenet: 3.000e e e e e e+02

60 Mintaillesztés Perl-ben is meg kell adni egy mintaszöveget, mely a program futása során összehasonlításra kerül a megvizsgálandó szöveggel, és amennyiben az illesztés sikeres, a visszatérési érték true, ellenkező esetben pedig false. Ezt nevezzük szabályos kifejezésnek. A mintát / jelekkel határoljuk, tekintsen meg egy egyszerű példát! @elemek = ("processzor","egér","nyomtató","monitor","alaplap"); foreach $elem { if ($elem =~ /o/) { print "$elem\n"; } Egy tömb került létrehozásra, majd az elemeiből egy foreach ciklussal végigmenve, egy elágazás segítségével a program kiírta az o betűt tartalmazó sztringeket. Ezek után már biztosan Ön is kitalálhatta a program kimenetét: processzor nyomtató monitor

61 Mintaillesztés A minta megadásánál használható egy előre megadott változó is: @elemek = ("asztal","ablak","Jakab","darabka","színház"); $minta = "ab"; foreach $elem { if ($elem =~ /$minta/) { print "$elem\n"; } A példa hasonló az előzőhöz, viszont itt a tömb létrehozása után egy $minta változó került dekralárásra, majd a változót, mint mintát hasonlítottuk össze a tömb elemeivel, az eredmény: ablak Jakab darabka

62 Mintaillesztés Ha azt szeretnénk, hogy a minta csak a vizsgálandó szöveg elejéhez kerüljön rögzítésre, akkor a minta elé egy ^ jelet kell tenni: @elemek = ("asztal","kapu","alma","inga","fal"); foreach $elem { if ($elem =~ /^a/) { print "$elem\n"; } Ebben az esetben csak az olyan tömbelemek kerülnek kiírásra, amelyek első karaktere egy a betű. Ha a minta [ebben az esetben az a] csak a sztring végéhez, vagy valamelyik belső karakteréhez illeszkedik, a kiválasztás nem történik meg. Ezek után nem meglepő a kimenet: asztal alma

63 Mintaillesztés A ^ párja a $, melynek ugyanaz a feladata, csak nem a szöveg elejéhez, hanem a végéhez próbálja illeszteni a mintát: @elemek = ("asztal","kapu","alma","inga","fal"); foreach $elem { if ($elem =~ /a$/) { print "$elem\n"; } Ebben az esetben pedig csak az a-ra végződő sztringek kerülnek kiválasztásra: alma inga Ugyanezt karaktersorozatokkal is meg lehet csinálni, a \b illetve a \B segítségével, ezek az egész mintára vonatkoznak, tehát például a /keszit\b/ kiválasztja a "keszit" vagy az "elkeszit" sztringet, viszont a "keszito"–t mar nem. Ennek ellentétje a \B, amely /keszit\B/ esetén kiválasztja a "keszito"-t, viszont a "keszit" –et vagy a "elkeszit"-et mar nem.

64 Mintaillesztés Egymás után többször szereplő karakterekre is lehet keresni, ebben az esetben a keresni kívánt karakter végére egy * jelet kell tenni. Az alábbi példa 0 vagy több l betűt keres: @elemek = ("üveg","gally","alma","autó","fal"); foreach $elem { if ($elem =~ /l*/) { print "$elem\n"; } A kimenet: üveg gally alma autó fal Bizonyára Ön is észrevette, hogy a * jelnek ebben a formában nincs túl sok haszna, mivel az akárhány karakterbe beletartozik a nulla karakter is, ergo azok az elemek is, amelyekben nulla darab l betű van.

65 Mintaillesztés Hasonló hatása van a + karakternek is, azonban ez egy vagy több karaktert keres. A *-ot +-ra változtatva már legalább egy l betű szükséges a kiíráshoz: @elemek = ("üveg","gally","alma","autó","fal"); foreach $elem { if ($elem =~ /l+/) { print "$elem\n"; } A kimenet: gally alma fal Használhatjuk a ? kifejezést is, mely az előtte szereplő karakterből nullát vagy egyet keres. A * jelhez képest ebben a példában nincs túl sok értelme [hiszen ugyanazt az eredményt adja], viszont a későbbiekben használni fogjuk.

66 Mintaillesztés Az eddig említett sokszorozókon kívül a Perl rendelkezik egy ún. általános sokszorozóval, mely arra való, hogy egy meghatározott tartományon belüli számszor ismétlődő mintát keresünk. A tartományt kapcsos zárójelekkel jelöljük, benne a két szélső értéket vesszővel elválasztva: @elemek = ("gally","alma","áll","autó","fal","galllly"); foreach $elem { if ($elem =~ /al{2,4}/) { print "$elem\n"; } A sztringekben egy a, és utána 2, 3, vagy 4 l betűt kerestünk. Az eredmény: gally galllly Az “áll” tömbelem azért nem szerepel itt, mert ugyan a két l betu megtalálható benne, viszont előttük nem “a” szerepel.

67 Mintaillesztés Az általános sokszorozó esetén nem csak tartományokat, hanem fix értékeket is meg lehet adni, vagy akár csak minimumot, vagy csak maximumot. Az alábbi példa öt darab a betűt keres: @elemek = ("van","vaaan","vaaaaan"); foreach $elem { if ($elem =~ /a{5}/) { print "$elem\n"; } Az eredmény, mivel csak ebben az egy szóban szerepelt egymás után 5 db a betű: vaaaaan Ha a sokszorozó használatánál minimum értéket szeretnénk megadni, azonban maximumot nem, akkor egyszerűen hagyjuk el a második számot, például így: /a{5,}/ Ez öt, vagy több a betűt keres. Az alábbi viszont pont az ellentéte: /a{,5}/ Ez pedig öt, vagy annál kevesebb a betűt keres.

68 Mintaillesztés A következő mintaillesztésnél használható operátor a pont (.), mely egy tetszőleges karaktert jelöl. Tekintsünk meg egy ide kapcsolódó példát! @elemek = ("van","vn","vaan"); foreach $elem { if ($elem =~ /v.n/) { print "$elem\n"; } Egy v betűt, majd egy [azaz nem több, és nem is kevesebb] tetszőleges karaktert, és egy n betűt keresett a program. Itt csak a van került kiválasztásra, mivel a "vn" –ben szerepel a v és az n, viszont nincs köztük semmilyen karakter, a "vaan" esetében pedig két darab karakter is található a v és az n között, ezért nem került kiválasztásra. Mint látható, a . operátor akármilyen karaktert elfogadott. Létrehozhatunk viszont karakterosztályokat, szögletes zárójelek segítségével, ekkor csak az itt megadott karaktereket engedélyezünk az adott helyen. Például az alábbi karakterosztály magába foglalja a számokat 0-9-ig: [ ] Persze ha több, egymás után következő számot vagy betűt akarunk megadni, akkor lehetőség van rövidítésre, mivel itt is használható egy tartományoperátor: [0-9]

69 Mintaillesztés Ugyanezt megcsinálhatjuk betűkkel is: [a-z]
Egy zárójelen belül akár keverhetünk számokat, betűket, és nagybetűket is: [a-zA-Z0-9] A fenti karaktercsoport egyenértékű az alábbival: [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ] Tekintsük meg, hogyan működik ez a gyakorlatban! @elemek = ("asztal","ASZTAL","aSzTaL"); foreach $elem { if ($elem =~ /[a-z]/) { print "$elem\n"; } A kimenetre a következők kerülnek: asztal aSzTaL

70 Mintaillesztés Tekintsünk meg egy példát, mely különválasztja a szavakat és a számokat: @elemek = ("autó","3","bogár","354","7465","TEVE","54"); foreach $elem { if ($elem =~ /[a-zA-Z]{2,}/) { print "$elem - szó\n"; } elsif ($elem =~ /[0-9]/) { print "$elem - szám\n"; } A kimenet: autó - szó 3 - szám bogár - szó 354 - szám szám TEVE - szó 54 - szám

71 Mintaillesztés Vannak olyan karaktercsoportok, amelyek már alapban szerepelnek a Perl-ben, ilyenek például: \d szám \D nem szám \w szó \W nem szó \s üres karakter [pl. szóköz, tabulátor, sortörés, stb.] \S nem üres karakter Ha például szavakat szeretnénk keresni, akkor elég a \w –t használni, mely egyenértékű a [a-zA-Z0-9_] karaktercsoporttal. Mint látható, a “szó”-ba beletartoznak a számjegyek, és az aláhúzás karakter is (_). A \d pedig egyenértékű a [0-9]-el, tehát például számokat az alábbi módon is kereshet: /\d/

72 Mintaillesztés Mintaillesztésnél lehetőség van zárójelek használatára, mely segítségével egy mintarészletet eltárolhatunk, és a minta későbbi részében hivatkozhatunk rá egy \ jel és számok segítségével annak megfelelően, hogy hányadik eltárolt karakterről van szó. Például: @elemek = ("-b-c-d-b-c-d","-d-k-g-h-k-g","-z-f-g-z-f-g"); foreach $elem { if ($elem =~ /-(.)-(.)-(.)-\1-\2-\3/) { print "$elem\n"; } A kimenet: -b-c-d-b-c-d -z-f-g-z-f-g Ez a példa 6 db kötőjelekkel elválasztott betűt keres, a feltétel csak annyi, hogy az első három betűnek ugyanolyannak kell lennie, mint a második három betűnek. Ezért van az, hogy a -b-c-d-b-c-d és a -z-f-g-z-f-g megfelelő volt, viszont a -d-k-g-h-k-g már nem.

73 Mintaillesztés Tekintsünk meg egy példát, amelyben egy többsoros változó szerepel! $tobbsoros = "elso sor\nmasodik sor\nharmadik sor"; if ($tobbsoros =~ /sor./) { print "igaz"; } else { print "hamis"; } A skalár létrehozása után megvizsgáltuk, hogy van-e benne olyan karaktersorozat, hogy "sor", és hogy szerepel-e utána egy bármilyen más karakter. Mint látható a skaláron, három helyen is szerepel benne a "sor", viszont kétszer sortörés van utána, egyszer pedig a változó végén áll. Ezért a program azt fogja kiírni, hogy "hamis". Az alábbi példa az s paraméter használatát mutatja be: if ($tobbsoros =~ /sor./s) { A lezáró / jel után egy s betűt írtunk, így már a program azt írta ki, hogy igaz. De miért? Azért, mert az s paraméter használatával a sztringet a Perl egy sorként fogja tekinteni, azaz így már az első két helyen, ahol előfordul a “sor”, már következni fog valami utána, így a kifejezés true értékkel tér majd vissza.

74 Mintaillesztés Végül még egy apróság, a levédő karakter, vagyis a \ jel, mely ebben az esetben is használható, ha például a mintában / jelet szeretnénk alkalmazni, akkor ezt le kell védeni a \ jellel [tehát így: \/], ellenkező esetben a Perl azt hiszi, hogy vége van a mintának. Mivel a \ jelnek is speciális szerepe van, ha a mintában használni szeretné, ezt is le kell védeni önmagával, azaz \\-t kell írni, ugyanígy a [, %, &, ^, $, stb. karakterekkel, amelyek valamilyen funkcióval rendelkeznek.

75 Köszönöm a figyelmet!

76 Felhasznált irodalom