Perl

Környezet

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

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.

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.

Példák:

	$i = 2;				# egész
	$f = 2.3;			# racionális
	$szam = 1_000_000_000;		# ez egy nagy egész
	$hexa = 0xffeedd;		# hexadecimális szám
	$szoveg = "Ez egy szoveg";	# egy szöveg
	print "Valami\n";		# egy szöveg megjelenítése
	print <<VEGE;			# hosszabb szöveg megjelenítése
	Valami				# "Itt a dokumentum" stílusu
	VEGE				# adatbevitellel (VEGE a zárószimbólum)
	$szoveg = <<VEGE;		# $szoveg = "ez is szoveg\n"
	ez is szovega			# ez is megy
	VEGE
	fv(<<EGY, <<KETTO);		# sôt ez is!
	elso parameter
	EGY
	masodik parameter
	KETTO

Tömbök

	@tomb = ('elso', 2, $harom);	# háromelemû tömb
	%szinek = (			# asszociatív tömb
		'piros' => 0x00f,
		'kék' => 0x0f0,
		'zöld' => 0xf00,
		);

És az utóbbival ekvivalens alak:

	%szinek = (			
		'piros' , 0x00f,
		'kék' , 0x0f0,
		'zöld' , 0xf00,
		);		#egyszerû felsorolás, párosával

É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

	@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 felhasználása a tömb aktuális hosszát adja vissza.
É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) 

Szintaxis ... utasítások

A Perl program utasítások és dekralá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.
Annak ellenére, hogy a nyelv UNIX-szûrõ jellegû nyelvi elemeket is tartalmaz, minden utasítás csak egyszer kerül végrehajtásra, kivéve, ha ciklusban szerepel.

A nyelvben az utasítások és dekralá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

	utasítás if EXPR
	utasítás unless EXPR
	utasítás while EXPR
	utasítás until EXPR

	print "Hello kedves olvasó!\n" if $bobeszedu_program;

Összetett utasítás

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

	if (EXPR) BLOKK
		# BLOKK végrehajtódik ha az EXPR igaz
	if (EXPR) BLOKK1 else BLOKK2
		# ha EXPR igaz akkor BLOKK1, egyébként BLOKK2
		# lesz végrehajtva
	if (EXPR) BLOKK elsif (EXPR) BLOKK ... else BLOKK

	CIMKE while (EXPR) BLOKK
	CIMKE while (EXPR) BLOKK continue BLOKK

	CIMKE for (EXPR1; EXPR2; EXPR3) BLOKK

	for($i = 1; $i < 10; $i++) {		$i = 1;
	    ...					while($i < 10) {
	}					    ...
						} continue {
						    $i++;
						}

	CIMKE foreach változó (TOMB) BLOKK

	CIMKE BLOKK continue BLOKK

A ciklusokban használható a next, a last és a redo utasítás, melyek a ciklusbeli utasítások végrehajtását vezérlik. A fent említett next hatására a futás a ciklus elejére kerül, és a feltétel újratesztelésével folytatódik a mûködés. A redo ehhez hasonló, csak itt a feltétel tesztelése nélkül kerül a végrehajtás a ciklus elsõ utasítására. A last pedig a ciklusból kiugrik, és az utána következõ elsõ utasításon folyik tovább a program végrehajtása.
A három utasítás használatában érdekesség, hogy mindegyiket címkézni is lehet és ekkor az ugrások az adott címkével ellátott ciklusra vonatkoznak.

Mivel a blokk egy egyszer lefutó ciklusnak tekinthetõ, ezért ezek az utasítások blokkban is használhatóak.

A switch utasításra nincs külön forma, de van rá egypár lehetséges 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;
	}

Operátorok é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 NEM
and	balról jobbra	logikai ÉS
or, xor	balról jobbra	logikai VAGY-ok

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

ismétlés

egy szöveget meg lehet ismételni néhányszor, pl.: "ha"x3 == "hahaha"

konkatenácó

szövegek összefûzé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
	}
	

• & - cím-operátor, helyette a \ használható,
• * - dereferencia-operátor, erre valók a $,@,%,& operátorok
• (TYPE) - típus-kényszerítés

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

Mintaillesztés

Szövegkeresés netovábbja.

Használat

• Szövegrészek felismerésére: egy szövegben a grep programhoz hasonlóan kereshetünk szövegeket.
  Pl.: $sor =~ /keresettszo/;
• Szövegekben a sed-hez hasonlóan lecserélhetünk egyes részeket.
  Pl.:$sor =~ s/eredeti/ujszo/;
• Szövegekbôl kikereshetünk minket érdeklô részeket, és azokat szelektíven ki is nyerhetjük (mint az awk-ban). Pl.:($erdekes_szo) = /\s+(\w+)$/;

Módosítók

Az i módosító használatával így a /perl/i kifejezés a PeRL szövegre is illeszkedni fog.

Az x módosító tulajdonképpen arra jó, hogy egy kicsit lazább szintaxszissal írhassuk le a keresô kifejezéseket. Ezzel már lehetôség van többsoros, sôt megjegyzésekkel tûzdelt kifejezés írására is!

Regular Expressions, reguláris kifejezések

Az alapok

\	a következô karakter speciális
^	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 =~ /PERL.perl/s;	# igaz
	print "illeszkedik/\n" if $szoveg =~ /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álassza 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,}	n-szer vagy többször
{n,m}	n <= ismétlôdések száma <= m

Alapértelmezés szerint ekkor a leghosszabb ismétlôdés fog illeszkedni ezekhez a részekhez. Ha minimális számu illeszkedést szeretnénk, akkor mindegyik után odatehetjük a ? jelet:

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

Speciális karakterek

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ô.

Csoportosítás

Ha egy csere környezetben használjuk, akkor az így kapott karaktersorozatokra a $1, $2, $3 ... változókkal lehet hivatkozni:

	s/^([^ ]*) *([^ ]*)/$2 $1/;		# elsô két szó felcserélése
	if(`date` =~ /(..):(..):(..)/) {	# idô kiírása
		print "ora: $1, perc: $2, masodperc: $3\n";
	}

Ha lista környezetben használjuk az illesztést, akkor a kiválasztott értékeket közvetlenül is megkaphatjuk:

	($ora, $perc, $masodperc) = (`date` =~ /(..):(..):(..)/);

Operátorok átlapolása

	package Valami;
		%OVERLOAD = (
			'+' => \&myadd,
			'-' => \&mysub;
			# stb.
		);
	...
	package main;
		$a = new Valami 57;
		$b = $a + 5;

Beépített függvények

Ez a rész iszonyú nagy, és csomó olyan információt tartalmaz, amit már amúgy is ismer az ember (legalábbis a C programokban használta már ôket). Itt csak néhány speciális dolgot fogok ismertetni, ami Perl jellegzetesség.

Ha valaki ismeri a szokásos C függvényeket, akkor azokat bátran használhatja, bizosan megvan. Ha nem úgy viselkedik, ahogy várta, akkor érdemes igénybe venni a POSIX modult:

	use POSIX;

Ha valakinek még ez sem elég, akkor igénybeveheti a különbözô modulokat. Már a nyelvvel együtt lehet találni adatbáziskezelô kiterjesztésektôl kezdve a terminálkezelô függvényekig sok mindent. Ezeken kívül az Internetben legalább száz új modul kínál kiterjesztéseket különféle nyelvek és könyvtárak felé (pl.: SQL adatbázikezelés, X11 grafikus felület, Prolog...).

néhány függvény...

bless REF,PACKAGE

A REF referenciát egy PACKAGE modulban leírt objektumként fogja kezelni. Lényegében ez az útja egy új objektum létrehozásának.

caller

Megmonja, hogy ki hívta az aktuális kódrészletet...
($package, $filename, $line) = caller;

chop

Levágja a '\n' jelet a sor végérôl. Ez sorok olvasása után hasznos.

		while(<>) {
			chop;	# $_ végérôl vág
			...
		}
		chop($cwd = `pwd`);	# aktuális könyvtár
	

defined EXPR

Megmondja, hogy egy EXPR változó definiált-e.

delete EXPR

Egy elem törlése egy asszociatív tömbbôl, pl.: delete $tomb{"eleme"};

die LIST

Ez lényegében a C könyvtári exit() függvény, csak a LIST tartalmát még kiírja mielött kilép a programból.

do BLOCK

Végrehajtja a BLOCK-ot majd az utolsó utasítás értékét adja vissza. Ha ciklusmódosítóval használjuk, akkor a ciklusmag még a tesztelés elõtt biztos lefut.

do EXPR

Az EXPR-t, mint Perl forrásnevet használja, és végrehajtja a benne lévõ utasításokat.Minden hívásnál újra kielemzi a fájlnevet, ezért nem érdemes például ciklusban használni.

dump LABEL

Egy core dump! Ha a core dump eredményeképpen kapott file-t futtatjuk, akkor az a LABEL cimkénél fog elindulni.
Ez a módja egy Perl prgram "fordításának".

each ASSOC_ARRAY

Egy asszociatív tömb elemeit iterálja:

		while(($key,$value) = each %ENV)
		{
			print "$key=$value\n";
		}
	

környezeti változók kiírása (ld. még a változókat)

eval BLOCK

A BLOCK futtatása az aktuális környezetben. A BLOCK egy string is lehet!

exists EXPR

Megmondja, hogy létezik-e az asszociatív tömb egy eleme, pl.: if exists $tomb{"eleme"} ...

glob EXPR

EXPR file-név teljesen kiterjesztve. Úgy mûködik mint a shell-ek file-név kiterjesztô algoritmusa.

keys ASSOC_ARRAY

ASSOC_ARRAY kulcsait adja vissza egy tömbben.

local EXPR

EXPR-ben felsorolt változók a blokkra nézve lokálisak lesznek. Ez a dinamikus láthatóságh.

my EXPR

EXPR-ben lévô vátozók csak az aktuális blokk-ban lesznek láthatóak. A local-tól eltérôen ez fordítási idôben értékelôdik ki, tehát a változónevekben nem lehetnek mágikus karaktertek. Az így definiált változók inkább a C nyelv lokális változóihoz állnak közel, mert a külvilág számára teljesen láthatatlanok lesznek.

		sub kiir 
		{
			my ($szoveg1, $szoveg2) = @_;
			chop $szoveg1;
			chop $szoveg2;
			print $szoveg1, ':', $szoveg2, '\n\n';
		}
	

open FILEHANDLE, EXPR

EXPR-ben leírt file megnyitása a FILEHANDLE leíróba.

		open(FILE,"valami.txt");	# írás-olvasás
		open(BE,"</etc/passwd");	# olvasás
		open(KI,">/tmp/output");	# írás
		open(FINGER,"finger @augusta |"); # olvasás pipe-ból
		open(RENDEZ,"| sort >/tmp/ki");# írás pipe-ba
	

Az így megnyitott file-okat a close-val lehet lezárni, és I/O mûveletekben lehet használni:

		print FILE "Egy szor\n";	# "Egy sor" kiírása a FILE-ba
		$sor = <BE>			# sor olvasása
	

pack MINTA,LIST

A LIST tartalmát a MINTA szerint binárisan összepakolja. Fôleg külsô eljárások hívása elött kell megtenni.

print FILEHANDLE LIST

Kiírás általános utasítása. A FILEHANDLE elhagyható, ekkor a standard kimenetre ír ki. A FILEHANDLE és a LIST között nem lehet vesszô!

return

Alprogramból érték visszaadása. Ha ez nem szerepel, akkor az alprogram utolsó utasításának értéke lesz visszaadva.

shift LIST

A LIST tömböt elmozdítja egy elemmel lefele. Az elsô elemmel tér vissza, és az törlôdik is abból.

sort LIST, vagy sort SUBNAME LIST

LIST rendezése lexikografikusan, vagy a SUBNAME-ben definiált alprogramnak megfelelôen. A SUBNAME alprogramnak egy érvényes összehasonlításnak kell lenni.

study SCALAR

Az adott változó tartalmát tanulmányozza egy kicsit, hogy késôbb több mintaillesztést hatékonyabban végezhessünk el rajta. Ez tényleg csak akkor jó, ha több mintaillesztést használunk ugyanarra a változóra!

tie VARIABLE,PACKAGENAME,LIST

Az adott változót hozzárendeli a PACKAGENAME-ben leírt struktúrához. Ezzel lehet egy egyszerû asszociatív tömbhöz hozzárendelni egy adatbázist, ahol a tömb indexei lényegében keresési kulcsok lesznek.
A PACKAGENAME modulban a változó típusától függôen különbözô függvényeket kell megírni:

• asszociatív tömb
  • TIEHASH objectname, LIST
  • DESTROY this
  • FETCH this, key
  • STORE this, key, value
  • DELETE this, key
  • EXISTS this, key
  • FIRSTKEY this, key
  • NEXTKEY this, key
• tömb
  • TIEARRAY objectname, LIST
  • DESTROY this
  • FETCH this, key
  • STORE this, key, value
• skalár
  • TIESCALAR objectname, LIST
  • DESTROY this
  • FETCH this
  • STORE this, value

undef EXPR

EXPR változó megszüntetése

untie VARIABLE

Egy tie kapcsolat megszüntetése.

unapck

pack függvény ellenkezôje

use MODULE, LIST

MODULE modul LIST-ben felsorolt nevei láthatóvá válnak az aktuális package-ban. Ha a LIST elmarad, akkor a MODULE által exportált változók válnak láthatóvá.
A no kulcsszó a use ellentettje, azaz a láthatóságot megszünteti.

wantarray

Igaz lesz az értéke, ha a végrehajtás alatt álló alprogram visszatérési értékét egy listához akarjuk rendelni. Ezzel a függvényhívással az alprogram lényegében meg tudja nézni, hogy milyen környezetben hívták meg ôt, és ettôl függôen akár más-más típusú visszatérési értéke is lehet!

warn LIST

Mint a die, csak nem lép ki a programból.

Elôre definiált változók

awk-on nevelkedett emberek itt otthon érezhetik magukat.

Ha az awk-os neveket szeretnénk használni, akkor a

	use English;

A file-ok "objektum-szerû" használatához a

	use FileHandle;

	print KIMENET "Hello World!!!\n";
	KIMENET->print("Hello World!!!\n");

A változókból itt is csak a legfontosabbakat fogom megemlíteni:

$_,$ARG

Az alapértelmezett változó. Ha valahol nincs változó, akkor ott ez lesz használva.

$1,$2,$3...

Reguláris kifejezésekbôl kapott betücsoportok.

$&, $MATCH

Legutolsó mintaillesztésnél az illesztett rész.

$[

Ez a változó mutatja, hogy a tömbök hányadik elemén kezdõdik adat. Ez állítható a különbözõ nyelvekben megszokotthoz igazodva.

$`, $PREMATCH

Legutolsó mintaillesztésnél a $& elötti rész.

$', $POSTMATCH

Legutolsó mintaillesztésnél a $& utáni rész.

$., $NR

Utolsó olvasási mûveletnél az olvasott sor sorszáma. (Ez csak olvasható változóként kezelendô!)

$/, $RS, $INPUT_RECORD_SEPARATOR

Input rekordok elválasztása. Ez alapesetben az újsor karakter, de bármire lecserélhetô. Ha az üres stringet adjuk meg, akkor üres sorok lesznek a határok. Ez nem ugyanaz mint $/ = "\n\n";, mert a $/ = "\n\n"; több üres sort is egyetlen határnak tekint.

$|, $OUTPUT_AUTOFLUSH

Output bufferelését szünteti meg, ha az értéke nem egy.

$\, $ORS, $OUTPUT_RECORD_SEPARATOR

Az a karakter, amit a print ki fog írni minden sor végén. Ez alapesetben üres.

$?, $CHILD_ERROR

Utolsó gyermek process visszatérési értéke. Ez a wait() függvény visszatérési értéke, tahát a valódi exit() értéket ($? >> 8)-ként kaphatjuk meg.

$$, $PID, $PROCESS_ID

A process azonosító száma.

$<, $UID, $REAL_USER_ID

Valódi user azonosítója.

$>, $EUID, $EFFECTIVE_USER_ID

A futás közbeni jogok tulajdonosa. Ez az érték csak a setuid programoknál vált át a file tulajdonosának jogaira.
Ez persze írható változó, tehát a $> = 0; a root-tá válás egy módja, csak ez nem mindg fog bejönni :-).

$(, $GID, $REAL_GROUP_ID

Valódi csoport azonosítója. Ha a rendszer több csoportot is támogat egyszerre, akkor ez egy listája azoknak a csoportoknak, amiben a process benne van.

$), $EGID, $EFFECTIVE_GROUP_ID

Effektív csoport azonosítója. Ez setgid program futtatásakor különbözhet az elözôtôl.

$0, $PROGRAM_NAME

A programot indító parancs neve (egy Perl script-nál a script neve, nem a "perl" szó).

@ARGV

A parancssori argumentumok listája.

@INC

Azon könyvtárak listája, ahol a Perl elkezd keresgélni egy modul után.

%INC

A használt modulok tömbje (filenév,elérési-út) elemekkel.

%ENV

Környezeti változók tömbje, pl.:

		print "Otthonom: ", $ENV{"HOME"}, "\n";
	

%SIG

Kivételkezelôk tömbje.

		sub handler {	# az elsô paraméter a signal neve
			local($sig) = @_;
			print "Elkaptam $sig-t!\n";
			exit(0);
		}
		$SIG{'INT'} = 'handler';
		$SIG{'QUIT'} = 'handler';
		...
		$SIG{'INT'} = 'DEFAULT';	# alapértelmezett
		$SIG{'QUIT'} = 'IGNORE';	# figyelmen kívül hagy
	

Néhány Perl-beli esemény is kezelhetô így. A $SIG{__WARN__} a warn által kiváltott, a $SIG{__DIE__} pedig a die által kiváltott esemény lekezelésére szolgál. Mindkét esetben átadásra kerülnek a warn, illetve a die paraméterei.

Alprogramok írása

Alprogramok deklarálása:

	sub NEV;	# a NEV ismertté tétele
	sub NEV BLOCK	# deklarálás és definíció

	sub max { 
		my $max = pop(@_);
		foreach $elem (@_) {
			$max = $elem if $max < $elem;
		}
		$max;
	}

Alprogram hívása:

	&NEV;		# az aktuális @_-t adja tovább
	&NEV(LISTA);	# Ha &-t írunk, akkor () kötelezô
	NEV(LISTA);	# & elhagyható ha van () vagy már deklarált
	NEV LISTA;	# () elhagyható, ha a NEV már deklarált

Alprogram hívása akkor megy ilyen egyszerûen ha az az ôt tartalmazó modulban látható. Ha ettôl eltérô modulban lett deklarálva, akkor modulhivatkozással, vagy valamilyen objektum-orientált technikával kell meghívni a kívánt eljárást (ld. késôbb).

	$m = &max(1,2,3); 	# a hatás ugyan az
	$m = max 1 2 3;

Névtelen alprogram létrehozása:

	$alpref = sub BLOCK;	# deklarálás

	&$alpref(1,2,3);	# hívás

Névtelen alprogramok definiált környezete

 sub newprint {
        my $x = shift;
        return sub { my $y = shift; print "$x, $y!\n"; };
    }
    $h = newprint("Hello");
    $g = newprint("Üdvözlet");

    # Valamivel késõbb...

    &$h("világ!");

    &$g("mindenkinek");

    Hello, világ!
    Üdvözlet, mindenkinek!

type glob

Beépített függvények átlapolása

	use subs 'chdir';	#az átlapolandó beépített függvények
	chdir $valahova;	#az új chdir használata
	sub chdir { ... }	#a chdir megvalósítása

Modulok

Ja kérem, ez egy "komoly" nyelv!

package

Alap esetben egy egyszerû programban minden a main modulba kerül be. Ha leírjuk a package szót, akkor az ez után következô deklarációk már az új modulba fognak tartozni. A modul neveihez a :: hivatkozás operátorral férhetünk hozzá (ez régen egy ' jel volt, de az egyszerûbb olvashatóság érdekében, meg a C++ programozók kedvéért ez megváltozott).

	$elso = 1;	# ez a $main::elso

	package MODUL;	# uj modul kezdete

	$masodik = 1;	# $MODUL::masodik
	$elso = 1;	# $MODUL::elso

	$main::elso = 2;# $main::elso

Szimbólumtábla

A modulhoz a modul nevével megegyezô szimbólumtábla tartozik, ami lényegében egy asszociatív tömb: %main::, avagy %MODULE::. Az itt lévô bejegyzésekhez a *nev alakban is hozzáférhetünk.

	local(*main::alma) = *main::korte;
	local($main::{'alma'}) = $main::{'korte'};

Konstruktor, destruktor

	package hibakezeles;

	BEGIN {
		open(HIBAK,">./hibak");
	}

	END {
		close(HIBAK);
	}

	sub kezeles {
		local ($szoveg) = @_;
		print HIBAK $szoveg, "\n";
	}

Egy modulban lévô nevekhez a use kulcsszóval férhetünk hozzá:

	use MODUL;
	use hibakezeles kezeles;

	BEGIN { require MODUL; import MODUL; }

Bonyolultabb struktúrák

A gondok mindíg a mutatókkal kezdôdnek, de ez itt még álnevekkel is kombinálódik...

Perl 4-ben kicsit nehézkes volt a bonyolult adatstruktúrák kezelése, de most már vannak referenciák, így már mindazt a borzalmat el lehet követni, amit egy C programban csak el tudunk képzelni. Sôt még többet is, mert egy C programban nem lehetett a változóneveket menet közben manipulálni.

Referencák létrehozása

1. Legegyszerûbb a \ operátor használata. Ezzel egy újabb hivatkozást készithetünk egy változóra (egy már biztosan van a szimbólumtáblában):

   	$scalarref = \$scalar;
   	$arrayref = \@ARGV;
   	$hashref = \%ENV;
   	$coderef = \&handler;
   	

2. Névtelen dolgokra is lehet hivatkozni:

   	$arrayref = [1, 2, ['a', 'b', 'c']];
   	$hashref = {
   		'Ádám' => 'Éva',
   		'Clyde' => 'Bonnie',
   	};
   	$coderef = sub { print "Nem nyert!\n"; };
   	

Referenciák használata

1. Az egyszerû esetek, amikor egy egyszerû struktúrát szeretnénk használni:

   	$ketto = $$scalarref;
   	print "A program neve:",$$arrayref[0],"\n";
   	print "HOME=",$$hashref{'HOME'};
   	&$coderef(1,2,3);
   	

   Persze lehet mutatni mutatóra is:

   	$refrefref = \\\"valami";
   	print $$$$refrefref;
   	

2. Bármilyen hely, ahol egy referenciát kapnánk meg, helyettesíthetô egy blokkal, amely értéke a referencia lesz:

   	$ketto = ${$scalarref};
   	print "A program neve:",${$arrayref}[0],"\n";
   	print "HOME=",${$hashref}{'HOME'};
   	&{$coderef}(1,2,3);
   	

   No persze a blokk lehet bonyolultabb is:

   	&{ $inditas{$index} }(1,2,3);	# megfelelô eljárás indul
   	$$hashref{"KEY"} = "VALUE";	# 1. eset
   	${$hashref}{"KEY"} = "VALUE";	# 2. eset
   	${$hashref{"KEY"}} = "VALUE";	# 3. eset
   	${$hashref->{"KEY"}} = "VALUE";	# 4. eset
   	

   Itt az 1. és 2., illetve a 3. és 4. eset egyenértékû.

3. A fenti esetek egyszerûsítésére szolgál a -> operátor:

   	print "A program neve:",$arrayref->[0],"\n";
   	print "HOME=",$hashref->{'HOME'};
   	

   Ennek balértéke bármilyen kifejezés lehet, amely egy referenciát ad vissza. Ez az operátor el is hagyható {} vagy [] zárójelek között (de tényleg csak közöttük!):

   	$array[$x]->{"valami"}->[0] = "január";
   	$array[$x]{"valami"}[0] = "január";
   	

   Ezzel el is jutottunk a többdimenziós C-beli tömbökhöz:

   	$tomb[42][4][2] += 42;
   	

Szimbólikus hivatkozások

	$nev = "ize";
	$$nev = 1;	# $ize
	${$nev} = 2;	# $ize
	${$nev x 2} = 3;# $izeize
	$nev->[0] = 4; # $ize[0]
	&$nev();	# &ize()
	$modulom = "MAS"
	${"${modulom}::$nev"} = 5;	# $MAS::ize

OOP

Lehet enélkül manapság nyelvet készíteni?

Amit a Perl objektumokról tudni kell:

1. Egy objektum csak egy egyszerû referencia, amely történetesen tudja, hogy melyik osztályhoz tartozik.
2. Egy osztály egy package, amely tudja az objektum hivatkozásokat kezelni, és van némi támogatása az öröklésre.
3. Egy metódus az egy egyszerû alprogram, amelynek az elsô paramétere egy objektum referencia vagy egy package-név lesz.

Objektum

	package ValamiUj;
	sub new { bless {} }	# 1. verzió

	sub new {		# kicsit bonyolultabban...
		my $self = {};
		bless $self;
		$self->initialize();
		return $self;
	}

Az objektumokat újra meg lehet áldani. Ekkor az objektum az új osztályba kerül, az eredeti osztályát "elfelejti", hisz egy objektum egyszerre csak egy osztályhoz tartozhat. Ezek után az új osztálynak kell gondoskodnia az eredeti adattagokkal kapcsolatos teendõkrõl. ld.Destruktorok

Osztály

Egy osztályban csak a metódusok öröklésére van támogatás az @ISA tömbbön keresztül. Ez egy modul neveket tartalmazó tömb. Ha egy metódust nem található meg az aktuális package-ban, akkor az ebben a tömbben felsorolt modulok lesznek bejárva a hiányzó alprogramért. Ez egy mélységi keresés lesz. Ha itt sem talál semmit, és van egy AUTOLOAD nevû függvény, akkor megpróbálja ezzel elôszedetni a hiányzó eljárást. Ha ez a lehetôség sem járt sikerrel, akkor egy UNIVERSAL-nak nevezett modulban fog keresgélni a rendszer.

Az @ISA tömb szépsége az, hogy menet közben is lehet módosítani, azaz menet közben megváltoztathatjuk egy osztály leszármazási fáját!

Nyilvánvalóan az adattagok öröklésére is szükség van egy objektum-orientált nyelvben, ez a Perlben az @ISA tömb segítségével megvalósítható.

	package A;
        sub new {
                my $type = shift;
                my $self = {};
                $self->{'a'} = 42;
                bless $self, $type;
        }

        package B;
        @ISA = qw( A );		# A a B õsosztálya
        sub new {
                my $type = shift;
                my $self = A->new;
                $self->{'b'} = 11;
                bless $self, $type;
        }

        package main;
        $c = B->new;
        print "a = ", $c->{'a'}, "\n";
        print "b = ", $c->{'b'}, "\n";

Metódus

Alapvetôen kétfajta metódus van:

statikus metódus

Ez elsô paraméterében az osztály nevét kapja meg:

	package ValamiUj;
	sub holvagyok {
		my ($neve) = @_;
		print "holvagyok: $neve\n";
	}
	

Ez a következôképpen hívható:

	ValamiUj->holvagyok();
	

"rendes" metódus

Ez az elsô paraméterében egy referenciát vár.

	package ValamiUj;
	sub new {
		my $self = {};
		bless $self;
		$self->{elso} = 1;	# ez {"elso"}-vel egyenértékü
		$self->{ize} = 42;
		return $self;
	}
	sub kiir {
		my $self = shift;
		my @keys = @_ ? @_ : sort(keys(%$self));
		foreach $key (@keys) {
			print "\t$key => $self->{$key}\n";
		}
	}
	

És ennek hívása:

	use ValamiUj;
	$obj = ValamiUj::new();
	$obj->kiir();	# C++ stílus
	kiir obj "elso";	# "print" stílus
	

Destruktor

Ötletek

• Ha itt nem volt valami világos, akkor az eredeti - angol nyelvû - Perl dokumentációt érdemes megtekinteni. Ott egyes részek sokkal részletesebbek.

  	perldoc perl		# avagy
  	man perl		# avagy
  	netscape http://augusta.inf.elte.hu/langs/perl/perl.html
  	

• A Perl programok végét az __END__ sor is lezárhatja. Ezek után beírhatjuk a program dokumentációját, így az nehezebben vész el. Esetleg használhatjuk a perldoc formátumot, amit a perldoc paranccsal nézhetünk meg, és perlman, illetve perlhtml paranccsal generálhatunk belôle más formátumokat.
• Érdemes megnézni a Getopt::Long modulban a GetOptions függvény használatát. A parancssori argumentumok feldolgozása ezzel nagyon egyszerû.
• setuid programok írásánál hasznos lehet a -T parancssori paraméter amivel a taint üzemmódot kapcsolhatjuk be. Ezzel követni lehet az összes változó életét. A veszélyes parancsok nem lesznek végrehajtva, ha azok külsô forrásból származó információn alapulnak.
• Ha valamilyen bonyolultabb feladatba kezdünk (nagyobb mint 200 sor), akkor ellenôrizzük le nem írta-e meg valaki azt a dolgot. (Én már láttam 400 soros HTTP szervert Perl-ben, ami cgi-bin programokat is kezelt!)

  Pl.: ftp://ftp.kfki.hu/pub/packages/perl/CPAN/CPAN.html

• Érdemes mindent mindjárt kipróbálni fejlesztés közben, mert elég gyors a rendszer ahhoz, hogy több ezer soros program is másodpercek alatt elinduljon.