Függvények I.
Most egy, kissé talán szokatlan újdonság következik: függvények! Annyit elárulhatok, hogy nem grafikonrajzolásról vagy hasonlóról lesz most szó. A programozásban általában függvénynek hívnak egy adott feladatot elvégző programrészletet, ha azt a program többi részétől különválasztottuk, rendszerint a könnyebb kezelhetőség és áttekinthetőség érdekében. Kisebb programokban is előfordulhat, hogy ugyanazt a feladatot sokszor kell elvégezni egy programon belül. Ilyenkor ahelyett, hogy beszúrnánk az adott feladatot elvégző programrészletet minden egyes helyre, sokkal jobb megoldás ha egy helyen (a programtól elválasztva) létrehozzuk, majd valamilyen parancsot írunk arra a helyre, ahol használni akarjuk.
Ezt a különálló programrészt hívjuk függvénynek, azonban a függvények ennél általánosabb problémák megoldására is alkalmasak. Leegyszerűsített működési elvük az alábbi ábrán látható:
A függvényeknek átadhatjuk bizonyos változók értékeit, amiket aztán a függvény használhat, ezeket hívjuk paramétereknek. A függvény ezután össze-vissza szórakozik a paraméterekkel, közben olyan dolgokat is csinálhat, melyek hatással lehetnek a programra (ezek az ábrán a mellékhatások, például kiír valamilyen üzenetet). A végén pedig kidob valamilyen értéket, amit általában a paraméterek segítségével állít elő, ez a visszatérési érték.
Hogy megértsük ezeket, nézzünk néhány konkrét példát!
Függvények használata
Tegyük fel hogy egy programban két szám átlagát (vagy ha úgy tetszik, számtani közepét) kell kiszámolni! Ezeket változókban adjuk meg, majd kiírjuk az átlagukat.
$szam1 = 3; $szam2 = 5;
A ciklusok tanulásánál írtam, hogy több utasítást lehet egy sorba írni, de általában kerülendő, mert a program áttekinthetősége romlik. Több hasonló változó létrehozása esetében viszont általában nem, így a fentiekhez hasonló esetben az imént látott módon szoktam írni a kódot.
Most írjuk ki az átlagot (a számolást természetesen a PHP-vel végeztetjük):
$SZAM = ($szam1 + $szam2) / 2; print "Átlag: ".$SZAM;
Így az alábbi kimenetben gyönyörködhetünk:
Átlag: 4
Ebben eddig semmi újdonság nincs (kivéve ha nem tudtuk hogyan kell kiszámítani két szám átlagát :D). Mit kell tennünk, ha ezt a műveletet függvény segítségével szeretnénk végeztetni? Először is meg kell adnunk az átlag kiszámításának módját egy függvényben, majd a függvénnyel kell elvégeztetni a számításokat a megfelelő helyen. Ez az alábbi módon nézhet ki:
//függvény létrehozása
function atlag($a, $b){
$ab_atlag = ($a + $b) / 2;
return $ab_atlag;
}
//változók létrehozása
$szam1 = 3; $szam2 = 5;
//az átlag kiszámítása
$SZAM = atlag($szam1, $szam2);
print "Átlag: ".$SZAM;
Egyenlőre a legfelső 5 sort hagyjuk figyelmen kívül, a program alsó felére összpontosítsunk! Látható, hogy a változók létrehozása ugyanúgy történt, az átlag kiírása szintén, viszont a $SZAM változónak máshogy adtunk értéket: egy atlag nevű függvény segítségével. A függvény neve után kerek zárójelek között, vesszővel elválasztva átadtuk neki a paramétereket, amikre szüksége van az átlag kiszámításához, majd a függvény visszatérési értéke került a $SZAM változóba.
A változók értékadásánál tanultuk, hogy mikor egy változó nevét használjuk (értékadásra, kiírásra, stb.), akkor a változó nevének helyére a változó értéke kerül a program végrehajtása során. Vagyis ahova pl. a $szam1 változót írjuk, annak olyan lesz a hatása, mintha az értékét (vagyis a 3-as számot) írtuk volna oda. Valami hasonlót lehet elképzelni az atlag függvény esetén is. Ahova az atlag függvényt írjuk (utána kerek zárójelben a paraméterek listájával), oda a függvény visszatérési értéke kerül a program végrehajtása során. Vagyis amikor a $SZAM változónak értéket adunk, akkor az atlag($szam1, $szam2) kifejezés helyére a 4-es szám kerül (nyilván ezt is várjuk el a programtól).
Látható tehát, hogy ha van egy függvényünk, akkor azt úgy tudjuk használni, hogy a függvény neve után kerek zárójelek közt megadjuk a paraméterek listáját, amiben az egyes paramétereket vessző választja el. Amikor használjuk a függvényt, azt úgy szokták nevezni, hogy a függvény hívása. Vagyis a print fölötti sorban meghívjuk az atlag függvényt, hogy értéket adjunk a $SZAM változónak. Most nézzük meg, hogyan hozunk létre egy függvényt!
Függvények létrehozása
A függvény létrehozása a programban meg kell előzze a függvény használatát (hasonló a helyzet, mint a változók esetén). Függvényt bárhol létrehozhatunk a kódban, de általában érdemes a PHP kódrészlet elején, vagy akár egy külön kódrészletben. Ez alatt azt értem, hogy ugyanabban a fájlban egy korábbi <?php ... ?> blokkban. Például:
<html> <head> <title>Cím</title> </head> <body> <?php // függvények létrehozása // ... ?> Különféle HTML kódok ... <?php // függvények használata // ... ?> </body> </html>
Arról, hogy hova rakhatunk a HTML kódon belül PHP blokkokat, a 20. leckében szó lesz, egyenlőre rakjunk mindent továbbra is a <body></body> tegek közé!
Függvény létrehozása általános esetben így néz ki:
function függvénynév(paraméterlista){
utasítások
return kifejezés;
}
Itt a function és a return kulcsszavak, nem írhatunk helyette mást (olyan mint például a while, if, else). A function azt jelenti, hogy most egy függvény definíciója (vagyis létrehozása) következik. Ezután megadjuk a függvény nevét, melyre ugyanazok a szabályok vonatkoznak, mint a változók neveire (kivéve hogy nincs benne $ jel). Ezután kerek zárójelek közt jönnek a paraméterek vesszővel elválasztva, vagyis ugyanolyan formában kell írni, mint a függvény hívása esetén. A paraméterek nevei azonban itt tetszőlegesek. A függvény definíciója ugyanis általánosan írja le, hogy mit fog csinálni a függvény a paramétereivel, ezeknek a konkrét értéke csak a függvény hívásakor ismert. Mivel ezek változók, ezért természetesen változóneveket kell kitalálnunk paraméterneveknek ($ jellel kell kezdődnie), de olyan nevet adunk, amilyet akarunk. Célszerű persze olyan nevet választani, ami utal a paraméter függvényben betöltött szerepére. Mindezek után kapcsos zárójelek közt következik a függvény leírása, vagyis annak a megadása, hogy pontosan mit fog csinálni a függvény. A kapcsos zárójelek közti részt szokták a függvény törzsének nevezni.
A függvény törzsében ugyanolyan utasítások szerepelhetnek, mint a program többi részében, vagyis változók létrehozása, elágazások, ciklusok, illetve más függvények hívása. A függvények ugyanis használhatnak más függvényeket változók értékének meghatározására, vagy bármilyen más célból! Sőt, hogy fokozzam az élvezeteket, a függvény saját magát is meghívhatja! Ilyen extrém esetekről majd a 14. leckében lesz szó.
A return utasítás bárhol szerepelhet a függvény törzsében (nem csak a legvégén!), de el is hagyható. Egyrészt arra szolgál, hogy a függvényből kilépjünk, másrészt a visszatérési érték az utána írt kifejezés értéke lesz. Itt ugyanúgy tetszőlegesen bonyolult kifejezéseket használhatunk, mint például a változók létrehozásánál. A return akkor nem szükséges, ha a függvénynek nincs visszatérési értéke, de függvényből való kilépésre ilyenkor is használható return; alakban, vagyis nem írunk utána kifejezést, csak a pontosvesszőt. Ha a függvény törzsének végére jutunk (vagyis a záró kapcsos zárójelhez), akkor itt akkor is kilépünk a függvényből, ha nincs return utasítás, tehát a függvény végére nem szükséges kifejezés nélküli return utasítást rakni.
Ilyen hosszú elméleti rizsa után nézzük meg részletesen egy konkrét példán, hogy mi történik egy függvény hívása során, és hogy pontosan hol halad a program végrehajtása ilyen esetekben!
Például létrehozunk egy jelszóellenőrző függvényt, aminek a paramétere a felhasználó által megadott jelszó, és ettől függően visszaad egy logikai értéket (pl. true-t ha jó jelszót adtunk meg, false-t ha nem). A program sorai előtt lévő számok a végrehajtási sorrendet mutatják:
//függvény létrehozása
(3) function check($jelszo){
if ($jelszo == "mittudomén"){
return true;
}
(4) else{
(5) print "Nem jó a jelszó!";
(6) return false;
}
print "Hoppá! Elszállt a program...";
}
//függvény használata
(1) $pass = "be akarok jutni";
(2)(7) if (check($pass) != true){
(8) exit();
}
//jelszóval védett oldal tartalma...
A program végrehajtása most nem a legelső sornál kezdődik, mivel az első fele egy függvény definíciója. Ez csak akkor fut le, ha a függvényt meghívjuk. A végrehajtás az (1)-essel megjelölt sorban kezdődik. Itt a $pass változóba kerül a felhasználó által megadott jelszó. Ezután jön egy feltételvizsgálat, aminek az a célja, hogy rossz jelszó esetén megszakítsa a programot, így az oldal tartalma nem jelenik meg. Ezt az exit(); paranccsal tehetjük meg, ahogy egy korábbi leckében már láthattuk. Látható, hogy a feltételvizsálatban a check nevű függvényt hívjuk, hogy vizsgálja meg a jelszót. Ezen a ponton a program végrehajtása a (3)-assal jelölt sorra ugrik, vagyis a függvény definíciójához. A (2)-es sorban a check függvénynek a $pass változót adtuk át paraméterként. A függvény definíciójában a paraméter neve $jelszo, ebbe bekerül a paraméter értéke (vagyis a "be akarok jutni" karakterlánc), és ezt a változót a függvény ugyanúgy használhatja, mint bármilyen más változót. Most jön a vizsgálat, hogy a paraméterként átadott jelszó helyes-e. Mivel itt a "mittudomén" a helyes jelszó, ezért a (4)-es sorban lévő else ág fog lefutni, vagyis ide ugrik a program. Először a függvény kiírja a print utasítással, hogy "Nem jó a jelszó!". Ez a függvénynek egy mellékhatása. Ezután a (6)-os sorban a return utasítás hatására kiugrunk a függvényből. A függvény visszatérési értéke a return után írt kifejezés értéke lesz, vagyis ebben az esetben a false logikai érték. Amikor a függvényből visszaugrunk, akkor a program végrehajtása ugyanott folytatódik, ahol a függvény hívása megtörtént, vagyis a (7)-es sorban. A check($pass) kifejezés helyére a visszatérési érték, vagyis a false kerül. Mivel a feltétel teljesül, ezért lefut az if ág, és végrehajtja az exit(); parancsot, vagyis a program futása megszakad.
Ha jó jelszót adtunk volna meg, akkor természetesen a függvényen belül az if ág hajtódott volna végre, és true értékkel tért volna vissza. Mivel a függvény if-else szerkezetének mindkét ágában van return, ezért a "Hoppá! Elszállt a program..." szöveg semmilyen esetben sem fog kiíródni! Ezenkívül azt is érdemes megemlíteni, hogy az if (check($pass) != true) feltételvizsgálat helyett írhattuk volna azt is, hogy if (!check($pass)) vagyis használhattuk volna a logikai nem operátort, mivel így false visszatérési érték esetén true érték kerül a feltételbe.
Arról, hogy a függvény pontosan mit tehet a $jelszo nevű változójával és milyen egyéb változókat használhat, hamarosan részletesen szó lesz. Most vizsgáljuk meg a függvény egyes részeit külön-külön!
Paraméterlista
Egy függvény paraméterlistája azokat a változókat sorolja fel, amikbe a függvény hívásakor az átadott paraméterek értékei kerültek. Egy függvény több paramétert is fogadhat, a számuk nincs korlátozva, de ilyenkor ügyelni kell arra, hogy milyen sorrendben adjuk meg őket. Mivel a paraméterek függvénydefinícióban szereplő neve tetszőleges, ezért a függvény hívásakor átadott értékek sorrendje határozza meg, hogy melyik változóba kerülnek. Nézzük az alábbi példát:
function conc($a, $b, $c){
return $a.$b.$c;
}
$egy = 1; $ketto = 2; $harom = 3;
print conc($egy, $ketto, $harom);
Ebben az esetben az $a változóba az $egy változó értéke (1-es szám), a $b-be a 2-es, a $c-be pedig a 3-as kerül. Vagyis a program az alábbi karakterláncot írja ki: "123". Ha viszont a függvényt például conc($harom, $egy, $ketto) formában hívjuk, akkor a visszatérési érték: "312".
A függvény hívása során először kiértékelődnek a paraméterek, majd ezután kerül sor a függvény hívására. Ez azt jelenti, hogy paraméterként bonyolult kifejezéseket, vagy akár közvetlenül az értéket is átadhatjuk. A fenti példánál maradva, ha a függvényt az alábbi alakban hívjuk:
conc(7, ($ketto*5) - 4, $egy);
akkor az $a változóba a 7-es szám kerül, a $b-be a ($ketto*5) - 4 kifejezés értéke (6), a $c-be pedig az $egy változó értéke (1) kerül. Így a visszatérési érték a "761" karakterlánc lesz.
Fontos, hogy a függvény hívásánál ugyanannyi paramétert adjunk át, amennyi a definícióban is szerepel. Létre lehet ugyan hozni olyan függvényeket, melyek paramétereinek száma változhat, de ezt a függvény definíciójában kell meghatározni, és ilyenekkel csak később foglalkozunk. Készíthetünk olyan függvényt is, ami nem fogad paramétert. Ekkor a definícióban a paraméterlistát üresen kell hagyni:
function semmi(){
print "Semmittevés";
return 0;
}
Természetesen visszatérési értékkel ettől függetlenül rendelkezhet a függvény. A hívásnál a paraméterlista ugyanígy néz ki:
print semmi();
Ez jelen esetben (mivel a print utasításban szerepel) kiírja a visszatérési értéket is, vagyis az alábbi kerül kiírásra: "Semmittevés0". Azért a "Semmittevés" karakterlánc kiírása történik előbb, mert a program először a semmi függvényt hajtja végre, hogy a visszatérési érték bekerülhessen a print utasítás után. Ezután történik a print 0; végrehajtása.
Ez a végrehajtási sorrend általánosan is igaz az összetett (egymásba ágyazott) kifejezéseke: először mindig a legbelső kifejezés értékelődik ki, majd utána a külső. Ebben semmi furcsa nincs, ugyanez történik például az 5-((1+5)*6) kifejezés kiértékelésekor is. Először a legbelső (1+5) értékelődik ki, majd az így létrejött (6*6) és végül az (5-36). Fordított irányban nyilván nem is lenne lehetséges. Függvényhívások egymásba ágyazása esetén ugyanez a helyzet:
function kiiras($szoveg){
print $szoveg;
}
kiiras(conc(1, semmi(), 2));
A kiiras függvény egyszerűen csak kiírja a paraméterét. Ebben az esetben először a conc paraméterlistája értékelődik ki. Az első és harmadik paraméterének értéke nyilván ismert, a második helyére a semmi függvény visszatérési értéke (0) kerül. Vagyis most a
kiiras(conc(1, 0, 2));
utasítássá egyszerűsödött a program adott sora. A kiiras függvény paramétere a conc visszatérési értéke lesz, ami ebben az esetben az "102" karakterlánc, így a következő lesz az eredmény:
kiiras("102");
A kiiras függvény ekkor meghívódik, aminek a mellékhatásaként kiíródik az "102" karakterlánc.
Látható, hogy a paraméterlista tetszőlegesen bonyolult kifejezéseket is tartalmazhat, de azért nem érdemes túlbonyolítani a helyzetet, mert nehezen átlátható kódhoz vezethet. Általában javasolható, hogy a bonyolult kifejezéseket ne a paraméterlistába írjuk, hanem adjuk értékül egy változónak, és ezt a változót adjuk át paraméterként.
Visszatérési érték
Ahogy azt már tudjuk, a függvény visszatérési értéke a return utasítás után írt kifejezés értéke lesz. A függvények a visszatérési értéküket rendszerint a paraméterek alapján állítják elő, de történhet máshogy is. Vannak függvények, melyek nem adnak vissza értéket, ezeket a programozásban néha eljárásoknak nevezik. A PHP-ben ezeket is függvényeknek hívják, mivel semmi másban nem különböznek a többitől. Tulajdonképpen ezek szolgálnak a lecke elején felvetett probléma megoldására, vagyis hogy bizonyos (gyakran használt) feladatokat elvégeztessünk a függvénnyel. Mivel itt nincs visszatérési érték, a függvény mellékhatása a lényeges, a mellékhatás létrehozása a célunk a függvény hívásával.
A return után tetszőlegesen bonyolult kifejezés is állhat. Például a két szám átlagát kiszámító függvényt így is megírhatjuk:
function atlag($a, $b){
return ($a + $b) / 2;
}
Sőt, akár függvényhívás is szerepelhet a return utasítás után. Miután a kifejezés kiértékelődött, a program kiugrik a függvényből, és a végrehajtása a függvény hívásánál folytatódik. Ha nincs visszatérési érték, akkor a return; formában írt utasítással ugorhatunk ki belőle. Amennyiben a program a függvény törzsének végére ért, és ott nincs return utasítás, akkor is kiugrik a függvényből visszatérési érték nélkül.
Könnyen írható olyan függvény is, amely bizonyos esetekben visszaad értéket, más esetekben pedig nem. Például itt egy osztást elvégző függvény, mely nullával való osztás esetén nem ad vissza értéket:
function div($a, $b){
if ($b == 0){
return;
}
return $a / $b;
}
Ha a második paraméter nulla, a függvényből kiugrunk, és nem adunk vissza értéket. Így az utolsó sorban lévő utasítás csak akkor hajtódik végre, ha $b nem nulla. Ha az osztás operátorát használjuk nullával való osztásra, akkor hibaüzenetet kapunk, ez a függvény egy lehetséges megoldást ad ennek kivédésére. Ennek ellenére nem javasolt olyan függvény készítése, mely egyszer visszaad értéket, máskor pedig nem, mert így nehezen megjósolható lehet a program viselkedése. Sok esetben célszerűbb valamilyen alapértelmezett érték, esetleg hibaüzenet visszaadása.
Függvénytörzs
A függvény törzsébe bármit írhatunk, ami azon kívül is szerepelhet a PHP kódban. Vagyis változók létrehozása, ciklusok, elágazások, függvényhívások, stb. A függvényen belüli változókkal kapcsolatban pár fontos dolgot feltétlenül meg kell említeni! Itt lényeges szerepet játszik a változók hatóköre. Egy változó hatóköre a PHP kód azon területe, melyen belül az adott változó elérhető (tudjuk használni). A függvényeken kívül létrehozott változók úgynevezett globális változók, ami azt jelenti, hogy az adott fájl PHP kódjában bárhol elérhető, kivéve a függvények belsejében. A függvények törzsében és a függvény paraméterlistájában szereplő változók lokális változók, vagyis csak az adott függvény belsejében használhatók. Nézzünk egy példát!
$glob = 2;
function semmi($par){
print $glob;
$loc = 8;
return $par;
}
print $loc.$par;
A fenti programban először létrehozunk egy globális változót, a $glob-ot. Majd definiálunk egy függvényt, ami megpróbálja kiírni (mellékhatásként) ezt a változót. Ez nem fog sikerülni, mivel függvényen belül nem tudjuk elérni a globális változókat. A függvényen belül létrehozunk egy lokális változót ($loc), amit ezután csak az adott függvény törzsében tudunk elérni. Ugyanez igaz a függvény paraméterére, a $par nevű változóra. Ezért, amikor a globális hatókörben (függvényen kívül) ki akarjuk íratni ezeket, egyik sem fog sikerülni. A végeredmény az, hogy semmi sem fog kiíródni. Ez olyan szempontból előnyös, hogy függvényen belül és kívül, illetve különböző függvényekben használhatjuk ugyanazokat a változóneveket, anélkül hogy felülírnák egymás változóit. Például:
$x = 2; // globális $x létrehozása
function foo($x){
$x = 5; // paraméter megváltoztatása
}
function bar(){
$x = 9; // lokális $x létrehozása
}
print $x; // globális $x kiírása
A fenti példában a globális $x-nek semmi köze a foo függvény paraméteréhez, vagy a bar függvényen belül létrehozott változóhoz. A nevük ugyan megegyezik, de más hatókörben vannak. Minden függvénynek saját lokális hatóköre van, ezért a fenti két függvény egymást sem fogja zavarni. A print utasítás (mivel a globális hatókörben szerepel) a globális $x értékét (2-t) írja ki.
A fentieknek van egy - elsőre talán meglepő - következménye: ha egy függvény megváltoztatja a paraméterét, akkor ez a változtatás nem lesz hatással arra a változóra, amit átadtunk a függvénynek a függvény hívásakor (mivel az a változó vagy a globális, vagy egy másik függvény lokális hatókörébe tartozik). A függvények csak az átadott paraméterek értékeit kapják meg híváskor, magukat a változókat nem, így azokat nem tudják megváltoztatni:
function add($a, $b){
++$a;
$b = 5;
return $a;
}
$A = 0; $B = 0;
add($A, $B);
Ebben a programban esetleg azt várhatnánk, hogy $A értéke 1, $B értéke pedig 5 lesz az add függvény meghívása (utolsó sor) után. Ez azonban nem így történik. Ha a hívás után kiíratjuk a változókat, látni fogjuk, hogy mindkettő értéke 0 maradt. A függvénynek viszont 1 lesz a visszatérési értéke, mivel a return utasítás a lokális paraméter ($a) értékét adja vissza.
Természetesen olykor szükség lehet egy globális változó elérésére függvényből, vagy arra, hogy a függvény meg tudja változtatni a paraméterként átadott változókat. Mindkettőre van lehetőség, arra viszont nincs, hogy egy függvény lokális változóját elérjük a függvényen kívülről, mivel a függvényből való kilépéskor a lokális változók megsemmisülnek. A legegyszerűbb módja globális változó elérésének, ha paraméterként átadjuk az értékét. Persze ilyenkor megváltoztatni nem tudjuk, és bizonyos esetekben ez a megoldás nem elfogadható. A globális változók függvényen belüli elérését a 17. leckében, paraméterként átadott változók módosításának módját pedig a 14. leckében ismerhetjük meg.
Példák
Talán ideje, hogy pár hasznos függvényt is mutassak páldaként, hogy lássuk, egyáltalán mi értelme függvényeket írogatni. Nézzünk például egy hatványozó függvényt:
function power($alap, $kitevo){
$hatvany = 1;
$x = 1;
while ($x <= $kitevo){
$hatvany *= $alap;
++$x;
}
return $hatvany;
}
Ez csak akkor működik, ha a kitevő pozitív egész szám. Nyilván az alap és a kitevő ismeretében kiszámítható a hatvány. Ezt függvényben pontosan ugyanúgy csináljuk, mint ahogy kint a programban csinálnánk, majd visszaadjuk a hatvány értékét.
Nézzünk egy olyan függvényt, ami első paraméterként egy karakterláncot vár, és azt annyiszor írja ki a kimenetre, amennyi a második paraméterének értéke:
function multiprint($szoveg, $szam){
if ($szam <= 0){
return;
}
$n = 1;
while ($n <= $szam){
print $szoveg;
++$n;
}
return;
}
A függvényben láthatóan nincs semmi különös, annyi az extra, hogy még mielőtt bármit csinálna, ellenőrzi, hogy a második paramétere pozitív szám-e. Ennek tulajdonképpen nincs túl sok értelme, mivel ha valaki nem tudja használni a függvényt, átadhat akár karakterláncot is második paraméterként. Ugyan van lehetőség ennek az ellenőrzésére is, viszont egy kiterjedt hibakezelés elég hosszú kódot eredményezhet. Általában a saját készítésű függvényeket nem mások használják, így csak akkor érdemes hibakezelést beleépíteni, ha azt bizonyos esetekben ki is használjuk (pl. ha ciklusmagban hívjuk meg a függvényt, és kaphat értelmetlen paramétert, de nem akarjuk hogy ilyenkor elszálljon a program).
Ennyi ízelítő talán elég is, ha további érdekes függvényeket szeretnél látni, oldd meg a következő feladatokat! :D
Házi feladat
1.) Alakítsuk függvénnyé a 7. lecke elején található szorzótáblát kiíró programot (6. lecke 3. házi feladata). Legyen a függvénynek egy paramétere, ami megadja hogy melyik szám szorzótábláját kell elkészíteni. A függvény írja ki a szorzótáblát, és ne legyen visszatérési értéke. Készítsük el a függvény olyan változatát is, mely nem ír ki semmit, hanem egy karakterláncot ad vissza, ami a szorzótáblát tartalmazza!
A feladat viszonylag egyszerű, tulajdonképpen csak annyit kell csinálni, hogy a $szam változót paraméterként rakjuk a függvénybe:
// Szorzótáblát kiíró függvény
function print_mtable($szam){
$n = 1;
while ($n < 10){
print $n." x ".$szam." = ".($n * $szam)."<br />";
++$n;
}
}
Mivel nincs visszatérési érték, a return utasítás elhagyható. Egyébként könnyen általánosítható a függvény például úgy, hogy megadjuk paraméterként azt, hogy meddig írja ki a szorzótáblát. Itt a 10-es számig írja ki, de ezt a számot paraméterként is be lehetne kérni. Ekkor az első sor így nézne ki:
function print_mtable($szam, $max)
Majd a ciklusfeltételben a 10-es szám helyére a paramétert kell írni.
Ha vissza kell adni a szorzótáblát, akkor a legegyszerűbb, ha egy üres karakterláncot hozunk létre, majd soronként feltöltjük:
// Szorzótáblát visszaadó függvény
function get_mtable($szam){
$table = "";
$n = 1;
while ($n < 10){
$table .= ($n." x ".$szam." = ".($n * $szam)."<br />");
++$n;
}
return $table;
}
2.) Oldjuk meg úgy az előző lecke 2. házi feladatát (1-től 1000-ig ki kellett íratni az összes prímszámot) úgy, hogy létrehozunk egy prim függvényt, ami true értéked ad vissza, ha a paramétere prímszám, különben false-t, és ezt a függvényt használjuk a feltételvizsgálatban.
Persze a legegyszerűbb az lenne, ha egyszerűen lemásolnánk a programot (pontosabban a cikluson belüli rész elejét), majd ezt beraknánk egy függvénybe, és a $prim változó értékét adnánk vissza. Így is jó, azonban itt egy olyan megoldást mutatok, ami jobban kihasználja a return utasítás lehetőségeit:
//függvény ami eldönti, hogy a paramétere prímszám-e
function prim($szam){
$x = 2;
while ($x <= ($szam / 2)){
if ($szam % $x == 0){
return false;
}
++$x;
}
return true;
}
//"főprogram"
$szam = 1;
while ($szam < 1000){
if (prim($szam) == true){
print $szam.", ";
}
++$szam;
}
A főprogramban csak a feltételvizsgálat változott, nincs benne semmi különös. A függvényben van lényegesebb változtatás. Amint kiderült, hogy a paraméter nem prím, kiugorhatunk a függvényből egy false értékkel, fölösleges ezt egy változóba rakni, majd a ciklusból való kiugrasztással szórakozni. Ha meg végigfutott a ciklus anélkül, hogy a függvényből kiugrottunk volna, akkor biztosak lehetünk benne, hogy a paraméter prímszám, így egyszerűen visszaadunk true értéket.
