Függvények

A függvény a jól szervezett program lelke, mert a programot könnyen olvashatóvá és
újrahasznosíthatóvá teszi. Függvények nélkül a nagy programok kezelhetetlenek lenn
ének. Ebben az órában a függvényeket tanulmányozzuk és mutatunk rá néhány
példát, hogyan kímélhetnek meg minket az ismétlõdésekbõl adódó pluszmunká-
tól. Az órában a következõket tanuljuk meg:
• Hogyan hozhatunk létre függvényeket?
• Hogyan adjunk át a függvényeinknek értékeket és hogyan kapjuk meg tõlük
az eredményt?
• Hogyan hívjunk meg függvényeket dinamikusan, változóban tárolt karakterl
ánc segítségével?
• Hogyan érjük el a függvényekbõl a globális változókat?
• Hogyan érjük el, hogy függvényeinknek „emlékezete” legyen?
• Hogyan adjunk át a függvényeknek hivatkozásokat?
Mit nevezünk függvénynek?
A függvényt egy gépnek tekinthetjük. A gép a bele töltött nyersanyagokkal addig
dolgozik, amíg a kívánt terméket elõ nem állítja vagy el nem éri kitûzött célját.
A függvény értékeket vesz át tõlünk, feldolgozza azokat és végez velük valamit
(például kiírja az eredményt a böngészõbe) vagy visszaad egy értéket, esetleg
mindkettõt.
Ha a kedves Olvasónak egy süteményt kell csinálnia, maga süti meg. De ha több
ezret, akkor esetleg készít vagy beszerez egy süteménysütõ gépezetet. Hasonló-
képp, amikor elhatározzuk, hogy függvényt írunk, a legfontosabb szempont, amit
mérlegelnünk kell, az, hogy az ismétlõdések csökkentésével akkorává zsugorodike
a program, hogy rövidebb lesz a függvény használatával.
A függvény valójában egy zárt, önálló kódrészlet, melyet programunkból meghívhatunk.
Amikor meghívjuk, a függvény törzse lefut. A függvénynek feldolgozás
céljából értékeket adhatunk át. Amikor a függvény véget ér, a hívónak egy értéket
ad vissza.
A függvény olyan kódrészlet, amely nem közvetlenül hajtódik végre,
hanem a programból hívhatjuk meg: onnan, ahol épp szükség van rá.
A függvények lehetnek beépítettek vagy felhasználó által megadottak. Mûködé-
sükhöz szükségük lehet információkra és többnyire értéket adnak vissza.
Függvények hívása
Kétféle függvény létezik: a nyelvbe beépített függvény és az általunk létrehozott
függvény. A PHP 4-ben rengeteg beépített függvény van. A könyv legelsõ
PHP oldala egyetlen függvényhívásból állt:
print ("Hello Web!");
ÚJDONSÁG
76 6. óra
A print abból a szempontból nem jellegzetes függvény, hogy
paramétereit nem kell zárójelbe tenni. A
print ("Hello Web!");
és
print "Hello Web!";
egyaránt helyes megoldások. Ez egy különleges függvény.
Szinte az összes többi függvénynél kötelezõ a zárójel; akár kell
paramétert átadnunk, akár nem.
A fenti példában a print() függvényt a "Hello Web!" szövegparaméterrel
hívtuk meg. A program a karakterlánc kiírását hajtja végre. A függvényhívás egy
függvénynévbõl (ebben az esetben ez a print) és az utána tett zárójelekbõl áll.
Ha a függvénynek információt szeretnénk átadni, azt a függvény utáni zárójelbe
tesszük. Az információt, amit ily módon adunk át a függvénynek, paraméternek
hívjuk. Néhány függvénynek több paramétert kell átadni. A paramétereket vesszõ-
vel választjuk el.
A paraméter a függvénynek átadott érték. A paramétereket a függvényh
ívás zárójelén belülre kell írnunk. Ha több paramétert kell átadnunk,
az egyes paramétereket vesszõvel kell elválasztanunk egymástól. A paraméterek
a függvényeken belül helyi (lokális) változóként érhetõk el.
valamilyen_fuggveny ( $elso_parameter, $masodik_parameter );
A print() abból a szempontból tipikus függvény, hogy van visszatérési értéke.
A legtöbb függvény, ha nincs „értelmes” visszatérési értéke, információt ad arról,
hogy munkáját sikeresen befejezte-e. A print() visszatérési értéke logikai típusú
(true, ha sikeres volt).
Az abs() függvény például egy szám típusú paramétert vár és a paraméter
abszolútértékét adja vissza. Próbáljuk is ki a 6.1. példaprogrammal!
6.1. program A beépített abs() függvény használata
1:
2:
3:
4:
5:
6: 7: $szam = -321;
8: $ujszam = abs( $szam );
9: print $ujszam; // kiírja, hogy "321"
10: ?>
11:
12:
ÚJDONSÁG
Függvények 77
6
Ebben a példában a $szam nevû változóhoz a -321-es értéket rendeltük, majd
átadtuk az abs() függvénynek, amely elvégzi a szükséges számításokat és visszaadja
az eredményt. Ezt az új értéket rendeljük az $ujszam nevû változóhoz és
kiírjuk az eredményt. A feladatot megoldhattuk volna segédváltozók segítsége
nélkül is, az abs() függvényt adva közvetlenül a print() paramétereként:
print( abs( -321 ) );
A felhasználó által megírt függvényeket teljesen hasonló módon kell meghívnunk.
Függvények létrehozása
Függvényt a function kulcsszó segítségével hozhatunk létre:
funcion valamilyen_fuggveny( $parameter1, $parameter2 )
{
// itt van a függvény törzse
}
A function kulcsszót a függvény neve követi, majd egy zárójelpár. Ha a függvény
paramétereket igényel, a zárójelbe vesszõvel elválasztott változókat kell tenni.
A változók értékei a függvényhíváskor átadott paraméterek lesznek. A zárójelpárt
akkor is ki kell írni, ha a függvény nem vesz át paramétereket.
A 6.2. példaprogram egy függvényt hoz létre.
6.2. program Függvény létrehozása
1:
2:
3:
4:
5:
6: 7: function nagyHello()
8: {
9: print "

HELLO!

";
10: }
11: nagyHello();
12: ?>
13:
14:
78 6. óra
A fenti program egyszerûen kiírja a "HELLO" szöveget egy

HTML elemben.
A programban egy olyan nagyHello() nevû függvényt hoztunk létre, amely
nem vesz át paramétereket. Ezért hagytuk üresen a zárójelpárt. Bár a nagyHello()
mûködõ függvény, mégsem túl hasznos. A 6.3. példaprogramban olyan függvényt
láthatunk, amely egy paramétert fogad és valami hasznosat csinál vele.
6.3. program Egy paramétert váró függvény létrehozása
1:
2:
3:
4:
5:
6: 7: function sorKiir( $sor )
8: {
9: print ("$sor
\n");
10: }
11: sorKiir("Ez egy sor");
12: sorKiir("Ez már egy másik sor");
13: sorKiir("Ez megint egy új sor");
14: ?>
15:
16:
Függvények 79
6
6.1. ábra
Függvény, amely egy
karakterláncot, majd
egy
HTML
elemet ír ki.
A 6.3. példaprogram kimenetét a 6.1. ábrán láthatjuk. A sorKiir() függvény
egy karakterláncot vár, ezért tettük a $sor nevû változót a zárójelbe.
Amit a sorKiir() függvény zárójelei közé teszünk, az kerül a $sor nevû változ
óba. A függvény törzsében kiírjuk a $sor nevû változót, majd egy
elemet
és egy újsor karaktert (hogy a HTML kód is olvasható legyen, ne csak a kimenet).
Ha most ki szeretnénk írni egy sort a böngészõbe, akkor meghívhatjuk
a sorKiir() függvényt, ahelyett, hogy a print() függvénnyel oldanánk meg
a problémát, így nem kell a sorvégi jeleket minden sor kiírásakor begépelnünk.
Függvények visszatérési értéke
A függvényeknek visszatérési értéke is lehet, ehhez a return utasításra van
szükség. A return befejezi a függvény futtatását és az utána írt kifejezést küldi
vissza a hívónak.
A 6.4. példaprogramban létrehozunk egy függvényt, amely két szám összegével
tér vissza.
6.4. program Visszatérési értékkel rendelkezõ függvény
1:
2:
3:
4:
5:
6: 7: function osszead( $elsoszam, $masodikszam )
8: {
9: $eredmeny = $elsoszam + $masodikszam;
10: return $eredmeny;
11: }
12: print osszead(3,5); // kiírja, hogy "8"
13: ?>
14:
15:
80 6. óra
A 6.4. példaprogram a 8-as számot írja ki. Az osszead() függvényt két paramé-
terrel kell meghívni (itt a két paraméter a 3 és az 5 volt). Ezek az $elsoszam és
a $masodikszam nevû változókban tárolódnak. Várhatóan az osszead()
függvény e két változó eredményét adja össze és tárolja az $eredmeny nevû
változóban. Az $eredmeny nevû segédváltozó használatát kiküszöbölhetjük:
function osszead( $elsoszam, $masodikszam )
{
return ( $elsoszam + $masodikszam );
}
A return segítségével értéket és objektumot is visszaadhatunk, vagy esetleg
„semmit”. Ha semmit sem adunk meg a return után, az csak a függvény futtatá-
sának befejezését eredményezi. A visszatérési érték átadásának módja többféle
lehet. Az érték lehet elõre „beégetett”
return 4;
de lehet kifejezés eredménye
return ( $a / $b );
vagy akár egy másik függvény visszatérési értéke is:
return ( masik_fuggveny( $parameter ) );
Dinamikus függvényhívások
Lehetõségünk van rá, hogy karakterláncba tegyük egy függvény nevét és ezt a változ
ót pontosan úgy tekintsük, mint ha maga a függvény neve lenne. Ezt a 6.5. példaprogramon
keresztül próbálhatjuk ki.
6.5. program Dinamikus függvényhívás
1:
2:
3:
4:
5:
6: Függvények 81
6
6.5. program (folytatás)
7: function koszon()
8: {
9: print "Jó napot!
";
10: }
11: $fuggveny_tarolo = "koszon";
12: $fuggveny_tarolo();
13: ?>
14:
15:
Itt a $fuggveny_tarolo változóhoz a koszon() függvény nevével azonos
karakterláncot rendeltünk. Ha ezt megtettük, a változót arra használhatjuk, hogy
meghívja nekünk a koszon() függvényt, csupán zárójeleket kell tennünk
a változó neve után.
Miért jó ez? A fenti példában csak még több munkát csináltunk magunknak azzal,
hogy a "koszon" karakterláncot rendeltük a $fuggveny_tarolo nevû változ
óhoz. A dinamikus függvényhívás akkor igazán hasznos, ha a program folyását
bizonyos körülményektõl függõen változtatni szeretnénk. Például szeretnénk mást
és mást csinálni egy URL-kérés paraméterétõl függõen. Ezt a paramétert feldolgozhatjuk
és értékétõl függõen más és más függvényt hívhatunk meg.
A PHP beépített függvényei még hasznosabbá teszik ezt a lehetõséget.
Az array_walk() függvény például egy karakterláncot használ arra,
hogy a tömb minden elemére meghívja a függvényt. Az array_walk()
alkalmazására a tizenhatodik órában láthatunk példát.
Változók hatóköre
A függvényben használt változók az adott függvényre nézve helyiek maradnak.
Más szavakkal: a változó a függvényen kívülrõl vagy más függvényekbõl nem lesz
elérhetõ. Nagyobb projektek esetén ez megóvhat minket attól, hogy véletlenül két
függvény felülírja azonos nevû változóik tartalmát.
A 6.6. példaprogramban létrehozunk egy változót a függvényen belül, majd megpr
óbáljuk kiíratni a függvényen kívül.
82 6. óra
6.6. program Változók hatóköre: A függvényen belül létrehozott változó
a függvényen kívülrõl nem elérhetõ
1:
2:
3:
4:
5:
6: 7: function proba()
8: {
9: $probavaltozo = "Ez egy proba valtozo";
10: }
11: print "proba valtozo: $probavaltozo
";
12: ?>
13:
14:
A 6.6. példaprogram kimenetét a 6.2. ábrán láthatjuk. A $probavaltozo értéke
nem íródik ki. Ez annak a következménye, hogy ilyen nevû változó a proba()
nevû függvényen kívül nem létezik. Figyeljük meg, hogy a nem létezõ változóra
történõ hivatkozás nem eredményez hibát.
Hasonlóképp, a függvényen kívül meghatározott változó nem érhetõ el automatikusan
a függvényen belülrõl.
Függvények 83
6
6.2 ábra
Kísérlet függvényen
belüli változóra
hivatkozásra.
Hozzáférés változókhoz a global kulcsszó segítségével
Alapértelmezés szerint a függvényeken belülrõl nem érhetjük el a máshol meghat
ározott változókat. Ha mégis megpróbáljuk ezeket használni, akkor helyi változót
fogunk létrehozni vagy elérni. Próbáljuk ki ezt a 6.7. példaprogrammal:
6.7. program A függvényen kívül meghatározott változók a függvényen
belül alapértelmezés szerint nem elérhetõk
1:
2:
3:
5:
6:
7: 8: $elet = 42;
9: function eletErtelme()
10: {
11: print "Az élet értelme: $elet
";
12: }
13: eletErtelme();
14: ?>
15:
16:
84 6. óra
6.3. ábra
Globális változó
elérési kísérlete
függvényen belülrõl
A 6.7. példaprogram kimenetét a 6.3. ábrán láthatjuk. Amint azt vártuk,
az eletErtelme() függvény nem tudta elérni az $elet változót; így az $elet
a függvényen belül üres. Ezt láthatjuk, amikor a függvény kiírja a változó értékét.
Mindent figyelembe véve ez egy jó dolog. Megmenekültünk az azonos nevû változ
ók ütközésétõl és a függvény paramétert igényelhet, ha meg szeretne tudni valamit
a „külvilág”-ról. Esetenként azonban egy-egy fontos globális (függvényen kívüli)
változót anélkül szeretnénk elérni, hogy azt paraméterként át kellene adnunk.
Ez az a helyzet, ahol a global kulcsszónak létjogosultsága van. A 6.8. példaprogram
a global kulcsszóval állítja vissza a világ rendjét.
6.8. program Globális változó elérése a global kulcsszó segítségével
1:
2:
3:
4:
5:
6: 7: $elet=42;
8: function eletErtelme()
9: {
10: global $elet;
11: print "Az élet értelme: $elet
";
12: }
13: eletErtelme();
14: ?>
15:
16:
Függvények 85
6
6.4. ábra
Globális változó
függvénybõl történõ
sikeres elérése a global
kulcsszó segítségével
A 6.8. példaprogram kimenetét a 6.4. ábrán láthatjuk. Miután az eletErtelme()
függvényben az $elet változó elé a global kulcsszót tesszük, a függvényen
belül a külsõ, globális $elet változót érhetjük el.
Minden függvényben, amely globális változót szeretne elérni, használnunk kell
a global kulcsszót.
Legyünk óvatosak! Ha most az $elet nevû változót a függvényen belül megváltoztatjuk,
annak a program egészére hatása lesz. A függvénynek átadott paraméter által
ában valamilyen érték másolata; a paraméter megváltoztatásának a függvény vége
után semmilyen hatása nincs. Ha azonban egy globális változó értékét változtatjuk
meg egy függvényen belül, akkor az eredeti változót változtattuk meg és nem egy
másolatot. Ezért a global kulcsszót lehetõleg minél kevesebbszer használjuk.
Állapot megõrzése a függvényhívások között
a static kulcsszó segítségével
A függvényen belüli változóknak egészében véve rövid, de boldog életük van.
Létrejönnek például akkor, amikor a szamozottCimsor() függvényt meghívjuk
és eltûnnek, amikor a függvény futása befejezõdik. Tulajdonképpen ennek így is
kell lennie. A lehetõ legjobb úgy felépíteni egy programot, hogy az független és kis
tudású függvényekbõl álljon. Esetenként azonban jól jönne, ha egy függvénynek
lehetne valamilyen kezdetleges memóriája.
Tegyük fel például, hogy tudni szeretnénk, hányszor fut le egy adott függvény.
Miért? Példánkban a függvény célja számozott címsor készítése, ami egy dinamikusan
létrejövõ dokumentációt eredményez.
Itt persze használhatnánk a global kulcsszóról újonnan szerzett tudásunkat.
Ennek alapján a 6.9. példaprogramhoz hasonlót írhatnánk.
6.9. program Változó értékének függvényhívások közti megõrzése
a global kulcsszó segítségével
1:
2:
3:
4:
5:
6: 86 6. óra
6.9. program (folytatás)
7: $fvHivasokSzama = 0;
8: function szamozottCimsor( $cimszoveg )
9: {
10: global $fvHivasokSzama;
11: $fvHivasokSzama++;
12: print "

$fvHivasokSzama. $cimszoveg

";
13: }
14: szamozottCimsor("Alkatrészek");
15: print("Az alkatrészek széles skáláját gyártjuk

");
16: szamozottCimsor("Mütyürök");
17: print("A legjobbak a világon

");
18: ?>
19:
20:
Ez úgy mûködik, ahogy azt vártuk. Létrehoztuk a $fvHivasokSzama nevû
változót a szamozottCimsor() függvényen kívül. A változót a függvény számára
a global kulcsszó segítségével tettük elérhetõvé. A 6.9. példaprogram kimenetét
a 6.5. ábrán láthatjuk.
Valahányszor meghívjuk az szamozottCimsor() nevû függvényt,
a $fvHivasokSzama változó értéke eggyel nõ, majd a megnövelt értékkel
a címsort teljessé tesszük.
Ez nem igazán elegáns megoldás. A global kulcsszót használó függvények nem
függetlenek, nem tekinthetõk önálló programrésznek. Ha a kódot olvassuk vagy
újrahasznosítjuk, figyelnünk kell az érintett globális változókra. Ez az a pont,
ahol a static kulcsszó hasznos lehet. Ha egy függvényen belül egy változót
Függvények 87
6
6.5. ábra
A függvényhívások
számának nyomon
követése a global
kulcsszó használat
ával
a static kulcsszóval hozunk létre, a változó az adott függvényre nézve helyi
marad. Másrészt a függvény hívásról hívásra „emlékszik” a változó értékére.
A 6.10. példaprogram a 6.9. példaprogram static kulcsszót használó változata.
6.10. program Függvényhívások közötti állapot megõrzése
a static kulcsszó használatával
1:
2:
3:
4:
5:
6: 7: function szamozottCimsor( $cimszoveg )
8: {
9: static $fvHivasokSzama = 0;
10: $fvHivasokSzama++;
11: print "

$fvHivasokSzama. $cimszoveg

";
12: }
13: szamozottCimsor("Alkatrészek");
14: print("Az alkatrészek széles skáláját gyártjuk

");
15: szamozottCimsor("Mütyürök");
16: print("A legjobbak a világon

");
17: ?>
18:
19:
A szamozottCimsor() függvény így teljesen független lett. Amikor a függvényt
elõször hívjuk meg, a $fvHivasokSzama nevû változó kezdeti értéket is kap.
Ezt a hozzárendelést a függvény további meghívásainál figyelmen kívül hagyja
a PHP, ehelyett az elõzõ futtatáskor megõrzött értéket kapjuk vissza.
Így a szamozottCimsor() függvényt már beilleszthetjük más programokba és
nem kell aggódnunk a globális változók miatt. Bár a 6.10. példaprogram kimenete
teljesen megegyezik a 6.9. példaprograméval, a programot elegánsabbá és
hordozhatóbbá tettük. Gondoljunk bele például, mi történne akkor, ha a függvény
6.9. példaprogrambeli változatát egy olyan programba illesztenénk bele, amelyben
van egy $fvHivasokSzama nevû változó.
88 6. óra
Paraméterek további tulajdonságai
Már láttuk, hogyan kell függvényeknek paramétereket átadni, de van még néhány
hasznos dolog, amirõl még nem beszéltünk. Ebben a részben megtanuljuk, miként
lehet a függvényparamétereknek alapértelmezett értéket adni és megtanuljuk azt is,
hogyan kell változóinkra mutató hivatkozást átadni a változó értékének másolata
helyett.
Paraméterek alapértelmezett értéke
A PHP nyelv remek lehetõséget biztosít számunkra rugalmas függvények kialakí-
tásához. Eddig azt mondtuk, hogy a függvények többsége paramétert igényel.
Néhány paramétert elhagyhatóvá téve függvényeink rugalmasabbá válnak.
A 6.11. példaprogramban létrehozunk egy hasznos kis függvényt, amely
egy karakterláncot egy HTML font elembe zár. A függvény használójának
megadjuk a lehetõséget, hogy megváltoztathassa a font elem size tulajdons
ágát, ezért a karakterlánc mellé kell egy $meret nevû paraméter is.
6.11. program Két paramétert igénylõ függvény
1:
2:
3:
4:
5:
6: 7: function meretez( $szoveg, $meret )
8: {
9: print "face=\"Helvetica,Arial,Sans-Serif\">$szoveg";
10: }
11: meretez("Egy címsor
",5);
12: meretez("szöveg
",3);
13: meretez("újabb szöveg
",3);
14: meretez("még több szöveg
",3);
15: ?>
16:
17:
Függvények 89
6
A 6.11. példaprogram kimenetét a 6.6. ábrán láthatjuk. Függvényünk ugyan
hasznos, de valójában a $meret nevû paraméter majdnem mindig 3. Ha kezdõért
éket rendelünk ehhez a paraméterhez, akkor az elhagyható lesz. Így ha a függv
ényhívásban nem adunk értéket ennek a paraméternek, akkor az általunk meghat
ározott értéket fogja felvenni. A 6.12. példaprogram ennek a módszernek
a segítségével teszi a $meret paramétert elhagyhatóvá.
6.12. program Függvény elhagyható paraméterrel
1:
2:
3:
4:
5:
6: 7: function meretez( $szoveg, $meret=3 )
8: {
9: print "Arial,Sans-Serif\">$szoveg";
10: }
11: meretez("Egy címsor
",5);
12: meretez("szöveg
");
13: meretez("újabb szöveg
");
14: meretez("még több szöveg
");
15: ?>
16:
17:
90 6. óra
6.6. ábra
Függvény, amely
formázott karakterl
áncokat ír ki a böng
észõbe
Ha a meretez() függvénynek van második paramétere, akkor a $meret nevû
változót ez fogja meghatározni. Ha a függvényhíváskor nem adunk meg második
paramétert, akkor a függvény a 3 értéket feltételezi. Annyi elhagyható paramétert
adhatunk meg, ahányat csak akarunk, de arra vigyáznunk kell, hogy az elhagyhat
ó paramétereknek a paraméterlista végén kell szerepelniük.
Hivatkozás típusú paraméterek
Amikor a függvényeknek paramétereket adunk át, a helyi paraméter-változókba
a paraméterek értékének másolata kerül. Az e változókon végzett mûveleteknek
a függvényhívás befejezõdése után nincs hatásuk az átadott paraméterekre.
Ennek igazolására futtassuk le a 6.13. példaprogramot.
6.13. program Függvényparaméter érték szerinti átadása
1:
2:
3:
4:
5:
6: 7: function ottelTobb( $szam )
8: {
9: $szam += 5;
10: }
11: $regiSzam = 10;
12: ottelTobb( $regiSzam );
13: print( $regiSzam );
14: ?>
15:
16:
Az ottelTobb() függvény egyetlen számot vár, majd ötöt ad hozzá. Visszatérési
értéke nincs. A fõprogramban a $regiSzam nevû változónak értéket adunk, majd
ezzel a változóval meghívjuk az ottelTobb() függvényt. A $regiSzam változó
Függvények 91
6
Ezt a korlátozást kikerülhetjük, sõt még a paraméterek sorrendjét
sem kell fejben tartanunk, ha a paramétereket egyetlen asszociat
ív tömbben adjuk át. (Errõl bõvebben a hetedik, tömbökrõl
szóló fejezetben lesz szó).
értékének másolata kerül a $szam nevû változóba. Amikor kiíratjuk a függvényhí-
vás után a $regiSzam változó értékét, azt találjuk, hogy az érték még mindig
10. Alapértelmezés szerint a függvények paraméterei érték szerint adódnak át.
Más szavakkal, a változók értékérõl helyi másolat készül.
Lehetõségünk van arra is, hogy ne a változó értékét, hanem arra mutató hivatkoz
ást adjunk át. (Ezt cím szerinti paraméterátadásnak is hívják.) Ez azt jelenti, hogy
a változóra mutató hivatkozással dolgozunk a függvényben és nem a változó érté-
kének másolatával. A paraméteren végzett bármilyen mûvelet megváltoztatja az
eredeti változó értékét is. Hivatkozásokat függvényeknek úgy adhatunk át, hogy
az átadandó változó vagy a paraméter neve elé egy & jelet teszünk. A 6.14. és
a 6.15. példaprogram az elõzõ problémára mutatja be a két elõbb említett
módszert.
6.14. program Cím szerinti paraméterátadás változóra mutatkozó
hivatkozás segítségével
1:
2:
3:
4:
5:
6: 7: function ottelTobb( $szam )
8: {
9: $szam += 5;
10: }
11: $regiSzam = 10;
12: ottelTobb( &$regiSzam );
13: print( $regiSzam );
14: ?>
15:
16:
92 6. óra
6.15. program Cím szerinti paraméterátadás
a függvénydeklaráció módosításával
1:
2:
3:
4:
5:
6: 7: function ottelTobb( &$szam )
8: {
9: $szam += 5;
10: }
11: $regiSzam = 10;
12: ottelTobb( $regiSzam );
13: print( $regiSzam );
14: ?>
15:
16:
Ha az átadandó paramétert alakítjuk hivatkozássá, akkor nem fogjuk elfelejteni,
hogy az átadott paraméter értéke megváltozhat, hiszen mi tettük hivatkozássá.
Ennek a változatnak viszont az a veszélye, hogy elfelejtjük kitenni az & jelet.
(C programozók már biztosan tapasztalták...) Ha a második megoldást választjuk,
akkor lehet, hogy elfelejtjük, hogy a paraméter értéke megváltozhat, viszont nem
felejtjük el kitenni az & jelet, mivel nem is kell kitennünk. Mindent egybevéve
talán több értelme van annak, hogy a függvénydeklarációban írunk & jelet
a paraméter neve elé. Így biztosak lehetünk benne, hogy az egyes függvényhí-
vások azonos módon viselkednek.
Összefoglalás
Ebben az órában megtanultuk, mik azok a függvények és hogyan kell õket haszn
álni. Megtanultuk, hogyan kell létrehozni és paramétereket átadni nekik. Elsajátí-
tottuk a global és a static kulcsszavak használatát. Megtanultuk, hogyan kell
a függvényeknek hivatkozásokat átadni és a paramétereknek alapértelmezett
értéket adni.
Függvények 93
6
Kérdések és válaszok
A global kulcsszón kívül van más mód arra, hogy egy függvény hozzá
tudjon férni vagy módosítani tudjon egy globális változót?
A globális változókat a programon belül bárhonnan elérhetjük a $GLOBALS nevû
asszociatív tömb segítségével. A $proba nevû globális változót például
$GLOBALS["proba"]-ként érhetjük el. Az asszociatív tömbökrõl a következõ
órában tanulunk.
A globális változót a függvényen belül akkor is módosíthatjuk, ha a függvény
paraméterként egy arra mutató hivatkozást kapott.
Kérdés: Lehet-e a függvényhívásokat a változókhoz hasonlóan karakterl
áncba ágyazni?
Nem. A függvényhívásoknak az idézõjeleken kívül kell lenniük.
Mûhely
A mûhelyben kvízkérdések találhatók, melyek segítenek megszilárdítani az órában
szerzett tudást. A válaszokat az A függelékben helyeztük el.
Kvíz
1. Igaz-e, hogy ha egy függvénynek nem kell paramétert átadni, akkor a függv
ény neve után nem szükséges kitenni a zárójelpárt?
2. Hogyan lehet függvénybõl értéket visszaadni?
3. Mit ír ki az alábbi kódrészlet?
$szam = 50;
function tizszer()
{
$szam = $szam * 10;
}
tizszer();
print $szam;
94 6. óra
4. Mit ír ki az alábbi kódrészlet?
$szam = 50;
function tizszer()
{
global $szam;
$szam = $szam * 10;
}
tizszer();
print $szam;
5. Mit ír ki az alábbi kódrészlet?
$szam = 50;
function tizszer($sz)
{
$sz = $sz * 10;
}
tizszer($szam);
print $szam;
6. Mit ír ki az alábbi kódrészlet?
$szam = 50;
function tizszer(&$sz)
{
$sz = $sz * 10;
}
$tizszer($szam);
print $szam;
Feladatok
1. Írjunk függvényt, amely négy karakterlánc típusú értéket fogad és olyan karakterl
ánccal tér vissza, amely paramétereit HTML cellaelemekbe (TD) zárja!