Függvények a PHP-ban (Paraméteres és paraméter nélküli függvények létrehozása, meghívása, hivatkozás szerinti paraméterátadás, típusmegfeleltetés, alapértelmezett érték)

Természetesen a PHP-ban is – csakúgy, mint a többi magas szintű programnyelvben – megtalálhatóak a függvények. Ebben a cikkben a beépített, illetve a felhasználó által létrehozott függvényekről lesz szó PHP nyelv alatt. Bemutatjuk, hogy hogyan készíthetsz paraméteres, illetve paraméter nélküli függvényeket és azt hogyan hívhatod meg őket. Továbbá lesz szó a szigorú típusmegfeleltetésről, a függvény alapértelmezett értékének beállításáról és a hivatkozás szerinti értékátadásról.

Függvények a PHP-ban (Paraméteres és paraméter nélküli függvények létrehozása, meghívása, hivatkozás szerinti paraméterátadás, típusmegfeleltetés, alapértelmezett érték) című cikk borítóképe

Függvények a PHP-ban (Paraméteres és paraméter nélküli függvények létrehozása, meghívása, hivatkozás szerinti paraméterátadás, típusmegfeleltetés, alapértelmezett érték)

Természetesen a PHP-ban is – csakúgy, mint a többi magas szintű programnyelvben – megtalálhatóak a függvények. Ebben a cikkben a beépített, illetve a felhasználó által létrehozott függvényekről lesz szó PHP nyelv alatt. Bemutatjuk, hogy hogyan készíthetsz paraméteres, illetve paraméter nélküli függvényeket és azt hogyan hívhatod meg őket. Továbbá lesz szó a szigorú típusmegfeleltetésről, a függvény alapértelmezett értékének beállításáról és a hivatkozás szerinti paraméterátadásról.

Mik azok a függvények?

A programozásban függvénynek nevezzük egy nagyobb program, apróbb, általában egy konkrét feladatot ellátó, a program többi részétől független kódrészletet. Ez a kódrészlet többször felhasználható, a konkrét kódrészletet ismétlődése nélkül. Ebből kifolyólag azokat a kódrészleteket is kiszervezzük függvényekbe, amelyeket egy program futása során többször felhasználunk.

Hasonló fogalmak, ám gyakran ekvivalensként kezeljük a függvény kifejezéssel az alábbiakat is:

  • eljárás
  • metódus
  • alprogram
  • szubrutin
  • procedúra

PHP függvények

Alapvetően kétfajta függvénytípust különböztetünk meg PHP-ban:

  • beépített függvények
  • felhasználó által létrehozott függvények

Beépített PHP függvéyek

A beépített PHP függvények olyan függvények, amelyeket alapértelmezetten (beépítve) tartalmaz a PHP. Azaz a létrehozásuk (megírásuk, leprogramozásuk) nélkül szabadon meghívhatóak a PHP szkriptből. Alapértelmezetten több, mint 1000 beépített PHP függvény található, melyek közül a legismertebbek, leggyakrabban használtak:

Beépített PHP függvényLeírás
is_numberigaz értékkel tér vissza, ha a megadott kifejezés szám
randvéletlenszerű számot generál
roundkerekíti a megadott számot
sqrtgyököt von a megadott értékből
sinvisszaadja a megadott érték szinuszát
datevisszaadja a dátumot egy tömbként
absvisszaadja egy szám abszolút értékét

Felhasználó által létrehozott függvények

A felhasználó által létrehozott függvények olyan függvények, amelyeket a PHP nem tartalmaz beépítetten, azaz sajátkezűleg nekünk (a felhasználónak) kell leprogramozni. (Vagy tartalmaz a PHP, de mi mégis inkább leprogramozzunk magunknak.)

Lentebb bemutatjuk azt, hogy hogyan hozhatunk létre saját függvényeket, illetve azt, hogy hogyan használhatjuk fel, azaz hogyan hívhatjuk meg őket.

Függvény létrehozása PHP-ban

Most, hogy tisztáztuk, hogy mi is az a felhasználó által létrehozott függvény, itt az ideje, hogy megmutassuk, hogyan tudunk egy saját függvényt létrehozni a PHP-ban.



Szintaxis:

function FÜGGVÉNYNÉV() {
   // függvény utasításai
}
Code language: PHP (php)

Először meg kell adnunk a “function” kulcsszót, amit a függvény neve követ egy nyitó és záró zárójelpárral. A nyitó kapcsoszárójel (“{“) jelzi, hogy honnan indul a függvényhez tartozó utasításblokk, majd a záró kapcsoszárójel (“}”) jelzi, hogy hol ér véget.

Fontos, hogy a függvény nevének betűvel vagy alsóvonással kell kezdődnie!

A függvények neve a változókéval szemben nem kis- és nagybetűérzékeny. Szóval a “fuggveny” és a “FUGGVENY” ugyanazt a függvényt takarja.

Mindig beszédes elnevezéseket adjunk a függvényeinknek, azaz próbáljuk leírni vele, hogy mit is csinál az adott függvény.


Példa függvény létrehozásására PHP-ban:

PHP kód

<?php
  function szovegKiiratas() {  // függvény nevének megadása
     echo "Ez az első függvényünk.";  // függvény utasításainak megadása
  }
?>
Code language: HTML, XML (xml)

A fenti példában létrehoztuk életünk első függvényét, melynek a neve “szovegKiiratas()”. Ez az elnevezés eleget tesz a fent említett igénynek, mely szerint beszédesen, a függvény funkcióját leíró névvel kell ellátnunk a függvényeinket. A függvény annyit csinál, hogy kiírja a képernyőre, hogy “Ez az első függvényünk.”. Az eredményét azért nem mutatjuk meg, mert a függvény létrehozásnak nincs szemmel látható eredménye. Ha szeretnénk, hogy látszódjon az eredménye, akkor meg kell hívnunk a függvényünket.

Függvény meghívása PHP-ban

Fentebb említettük, hogy az elkészített függvény alapvetően nem fut le, így nincs szemmel látható eredménye. Ha szeretnénk az elkészített függvény eredményét megjelentetni, akkor meg kell azt hívnunk.


Szintaktika:

FÜGGVÉNYNÉV();
Code language: PHP (php)

A meghíváshoz csak annyira van szükségünk, hogy megadjuk a már létrehozott függvény nevét két zárójellel. Ahol meghívjuk a függvényt, a függvény ott fog lefutni. Azaz, ha egy HTML oldalon belül hívjuk meg, akkor figyelnünk kell rá, hogy milyen elemek között tesszük meg.

A fenti példánál maradva, ha az oldal tetejére szeretnénk kiíratni a szöveget, akkor nem hívhatjuk meg az oldal alján.


Első példa függvény meghívására PHP-ban:

PHP kód

<?php
  function szovegKiiratas() {  // függvény nevének megadása
     echo "Ez az első függvényünk.";  // függvény utasításainak megadása
  }

  szovegKiiratas(); // itt hívjuk meg a függvényt
?>
Code language: HTML, XML (xml)

Eredmény

Ez az első függvényünk.


Második példa függvény meghívására PHP-ban:

PHP kód

<!DOCTYPE html>
<html>
<body>

	<?php
  		function szovegKiiratas() {  // függvény nevének megadása
     	echo "Ez az első függvényünk.";  // függvény utasításainak megadása
  		}
	?>


	<p>Első szöveg</p>
	<?php
		szovegKiiratas(); // itt hívjuk meg a függvényt
	?>
	<p>Második szöveg</p>

</body>
</html>

Code language: HTML, XML (xml)

Eredmény

Első szöveg

Ez az első függvényünk.

Második szöveg


A második példáról írtunk fentebb, hogy nagyon fontos a függvény meghívásának helye. Jelen példában a függvényt a két <p> tag között hívtuk meg, ezért a függvény eredménye a két <p> tag közé íródott be. Ha az első <p> elem előtt hívtuk volna meg, akkor az “Első szöveg” előtt jelent volna meg az “Ez az első függvényünk.” felirat.

Paraméteres függvény létrehozása PHP-ban

Most, hogy megismerkedtünk a függvények létrehozásával, illetve meghívásával, utólag bevezetjük azt a fogalmat, hogy paraméter. A fent látható függvények mind paraméter nélküli függvények voltak. Most pedig megismerkedünk a paraméteres függvényekkel.

A paraméterek segítségével lehetőségünk van, hogy adatot adjunk át a függvénynek. Ezt az adatot a függvény felhasználhatja futása során. A függvénynek bármennyi paraméter átadható, ezt mindig a feladat határozza meg. A különböző paramétereket vesszővel (“,”) kell elválasztanunk egymástól.


Szintaxis:

function FÜGGVÉNYNÉV($PARAMÉTER1, $PARAMÉTER2 ...) {
   // függvény utasításai
}
Code language: PHP (php)


Példa paraméteres függvény létrehozására PHP-ban:

PHP kód

<?php
  function szovegKiiratas($szoveg) {  // függvény nevének megadása, mely várja a $szoveg paramétert
     echo $szoveg;  // függvény utasításainak megadása
  }
?>
Code language: HTML, XML (xml)

A paraméteres függvény sem fut le alapértelmezetten, így meg kell hívnunk, hogy lássuk az eredményét.

Paraméteres függvény meghívása a PHP-ban


Szintaktika:

FÜGGVÉNYNÉV($PARAMÉTER1, PARAMÉTER2 ...);
Code language: PHP (php)

A paraméteres függvény meghívása sem tér el a paraméter nélkülitől, csak annyi változik, hogy itt meg kell adnunk az átadadndó paramétereket.


Példa paraméteres függvény meghívására PHP-ban:

PHP kód

<?php
  function szovegKiiratas($szoveg) {  // függvény nevének megadása, mely várja a $szoveg paramétert
     echo $szoveg;  // függvény utasításainak megadása
  }

  szovegKiiratas("Ez egy PHP függvény."); // a függvénynek konkrétan szöveget adunk át
  echo "<br>"; // kiíratunk egy <br>-t, hogy a két szöveg ne csússzon egybe
  $valtozo = "Ez egy változó.";
  szovegKiiratas($valtozo); // a függvénynek egy változót adunk át
?>
Code language: HTML, XML (xml)

Eredmény

Ez egy PHP függvény.
Ez egy változó.


A fenti példánkban kétszer hívtuk meg a “szovegKiiratas” függvényt, melynek először egy sima szöveget adtunk át paraméterként, másodszor pedig egy változót adtunk át, melynek előtte adtunk értéket.

A változó meghívásakor teljesen mindegy, hogy milyen névvel adjunk át a változót a függvénynek, de a függvényen belül csak úgy hivatkozhatunk rá, ahogy a függvény létrehozásakor elneveztük a paramétert.

Például a fenti példában a függvény létrehozásakor a paramétert “$szoveg”-nek neveztem el, így a függvényen belül csak a “$szoveg”-re hivatkozhatok. A meghívásakor az átadott függvény nevének nem kell “$szoveg”-nek lennie. Bármilyen függvénynévvel átadhatjuk, mi most “$valtozo”-ként adtuk át. Fontos, hogy az átadott változó neve, a függvényen belül már “$szoveg”-ként fog élni, azaz ott nem hivatkozhatunk a “$valtozo”-ra.

PHP szigorú típusmegfeleltetés

A PHP egy lazán típusos nyelv, ami azt jelenti, hogy egyes esetekben, például amikor változót hozunk létre, akkor nem kell megadnunk, hogy az adott változó milyen típusú lesz. A PHP automatikusan érzékeli és hozzárendel egy típust a változóhoz, anélkül, hogy mi meghatároznánk azt. Emiatt nyugodtan megtehetjük, hogy egy int-hez hozzáadunk egy string-et, ez egyáltalán nem fog problémát okozni.

A PHP 7 megjelenésekor bevezették a típus deklarációt is, ez lehetőséget ad számunkra, hogy meghatározzuk, hogy milyen típust várunk a függvényünk paraméterei számára. Ha a paraméterek nem felelnek meg az általunk vártaknak, akkor a PHP hibát fog dobni.


Szintaxis:

declare(strict_types=1);


function FÜGGVÉNYNÉV(TÍPUS $PARAMÉTER1, TÍPUS $PARAMÉTER2 ...) {
   // függvény utasításai
}
Code language: PHP (php)

Először is szükségünk van arra, hogy megadjuk a következőt: ,, declare(strict_types=1); “. Ez fogja kikényszeríteni a szigorú típusmegfeleltetést. Ezt csak egyetlen egyszer kell megadni a kód során, nem kell minden egyes függvény esetében újból és újból megadnunk. Továbbá eddigi függvény deklaráció annyival egészül ki, hogy a paraméterek elé megadjuk, hogy milyen típusút adatot várunk a helyükre.

Egy kis segítség, hogy milyen típusok vannak a PHP-ban:

  • string (szöveg)
  • int (egész szám)
  • float (valós szám)
  • boolean (logikai érték)


Első példa szigorú típusmegfeleltetésre:

PHP kód

<?php declare(strict_types=1);
  function szovegKiiratas(string $szoveg) {  // a paraméter csak string (szöveg) típusú lehet
     echo $szoveg;
  }

  $szovegTipus = "Ez egy változó.";
  szovegKiiratas($szovegTipus); // ezt kifogja írni
?>
Code language: HTML, XML (xml)

Eredmény

Ez egy változó.


Második példa szigorú típusmegfeleltetésre:

PHP kód

<?php declare(strict_types=1);
  function szovegKiiratas(string $szoveg) {  // a paraméter csak string (szöveg) típusú lehet
     echo $szoveg;
  }

  $szamTipus = 5;
  szovegKiiratas($szamTipus); // itt hibába fut
?>
Code language: HTML, XML (xml)

Eredmény

Fatal error: Uncaught TypeError: szovegKiiratas(): Argument #1 ($szoveg) must be of type string, int given…


Láthatjuk, hogy a fenti példa gond nélkül lefut, hiszen olyan típusú paramétert adtunk át a függvénynek, amilyet a függvény várt, míg az alsó példa “Fatal error”-t dob, mert nem megfelelő típusú paramétert adtunk át a változónak.

PHP függvény alapértelmezett érték (alapérték)

Lehetőségünk van arra is, hogy alapértelmezett értéket állítsunk be a függvényeink számára, ez akkor lehet hasznos, amikor a függvényt paraméter nélkül hívják meg. Beállíthatjuk, hogy a függvény ilyen esetekben úgy fusson le, mintha paraméterrel hívták volna meg. De mivel valójában nincs átadott paraméter, így be kell állítanunk egy alapértelmezett értéket.


Szintaxis:

function FÜGGVÉNYNÉV($PARAMÉTER1 = ALAPÉRTÉK, $PARAMÉTER2 = ALAPÉRTÉK ...) {
   // függvény utasításai
}
Code language: PHP (php)


Példa függvény alapértelmezett értékére PHP-ban:

PHP kód

<?php
  function szovegKiiratas($szoveg = "PHP függvény") {  // meghatározzuk, hogy a $szoveg változó alapértéke "PHP" függvény
     echo $szoveg;
  }

  szovegKiiratas(); // nem adunk át paramétert, így az alapértelmezettel fog lefutni
?>
Code language: HTML, XML (xml)

Eredmény

PHP függvény


A példában beállítottuk, hogy a $szoveg változónk alapértelmezett értéke a “PHP függvény” legyen, majd lentebb paraméter nélkül hívtuk meg a függvényt. Így a PHP kiolvasta a függvényben alapértékként definiált “PHP függvény” szöveget és úgy futott a program, mintha ezt adtuk volna át paraméterként a függvénynek.

PHP értékvisszaadás (return)

Eddig olyan függvényeket készítettünk, amelyek szimplán kiírtak valamit a képernyőre, de lehetőségünk van arra is, hogy legyen visszatérési értékük. Ilyenkor nem írunk ki semmit a képernyőre, csak a függvény visszaad egy értéket, amivel aztán azt kezdünk, amit csak szeretnénk, felhasználhatjuk egy másik függvényben, elmenthetjük egy változóban stb.


Szintaktika:

function FÜGGVÉNYNÉV(OPCIONÁLIS.PARAMÉTEREK) {
   // függvény utasításai
   return ÉRTÉK;
}
Code language: JavaScript (javascript)

Természetesen készíthetünk paraméteres, illetve paraméter nélküli függvényeket is, mind a kettőnek lehet visszatérési értéke.

A függvény utasításai után szimplán meg kell adnunk a “return” kulcsszót, majd azt az értéket, amit szeretnénk visszaadni.


Példa visszatérési értékre PHP-ban:

PHP kód

<?php declare(strict_types=1);
  function osszeadas(int $szam1, int $szam2) {  // meghatároztuk, hogy két egész számot várunk
     return $szam1+$szam2; // visszatérünk a két szám összegével, de nem íratjuk ki azokat
  }

  echo "5 + 10 = " . osszeadas(5,10); // itt hívjuk meg a függvényt
?>
Code language: HTML, XML (xml)

Eredmény

5 + 10 = 15

PHP értékvisszaadás (return) típus meghatározással

Természetesen arra is van lehetőségünk, hogy a függvény visszatérési értékére tegyünk szigorú típusmegfeleltetést.


Szintaxis:

declare(strict_types=1);

function FÜGGVÉNYNÉV(OPCIONÁLIS.PARAMÉTEREK) : VISSZATÉRÉSI.TÍPUS {
   // függvény utasításai
   return ÉRTÉK;
}
Code language: PHP (php)


Első példa visszatérési érték típusmegfeleltetésére PHP-ban:

PHP kód

<?php declare(strict_types=1);
  function osszeadas($szam1, $szam2) : int {  // meghatároztuk, hogy a visszatérési érték csak int lehet
     return $szam1+$szam2; // visszatérünk a két szám összegével, de nem íratjuk ki
  }

  echo "5 + 10 = " . osszeadas(5,10); // itt hívjuk meg a függvényt
?>
Code language: HTML, XML (xml)

Eredmény

5 + 10 = 15

Beállítottuk, hogy a visszatérési érték csak egész szám lehet, így a PHP kód gond nélkül lefut, hiszen két egész számot adunk össze, melynek az összege egy egész szám.


Második példa visszatérési érték típusmegfeleltetésére PHP-ban:

PHP kód

<?php declare(strict_types=1);
  function osztas($szam1, $szam2) : int {  // meghatároztuk, hogy a visszatérési érték csak int lehet
     return $szam1/$szam2; // visszatérünk a két szám hányadosával, de nem íratjuk ki
  }

  echo "5 / 10 = " . osztas(5,10); // itt hívjuk meg a függvényt
?>
Code language: HTML, XML (xml)

Eredmény

Fatal error: Uncaught TypeError: osztas(): Return value must be of type int, float returned…


A második példa esetében hibába futunk, hiszen a két bemenő érték valóban egész szám, de a visszatérési érték nem az.

PHP paraméterátadás hivatkozásként (mutató)

A PHP-ban lehetőségünk van paraméterátadásra hivatkozásként is. (Vannak olyan nyelvek, ahol mutatóknak, pointereknek nevezik ezt.) Az eddigi függvények esetében az átadott paraméterekkel végzett műveletek csak a függvényen belül voltak érvényesek, és nem befolyásolták az eredeti függvényen kívüli értékét a változónak.

Ha egy paramétert hivatkozásként adunk át, akkor nem egy, csak a függvényben létező változóval fogunk dolgozni, hanem azzal a változóval, amely a függvényen kívül is létezik.


Szintaxis:

function FÜGGVÉNYNÉV(&$PARAMÉTER1 ...) {
   // utasítások
}
Code language: PHP (php)

A változónév elé bebiggyesztünk egy és, and (“&”) jelet, semmi más nem változik.


Példa PHP paraméterátadásra hivatkozásként:

PHP kód

<?php
  // felveszünk két változót 5 és 10 értékkel
  $valtozo1 = 5;
  $valtozo2 = 10;
  
  echo "Előtte: $valtozo1 és $valtozo2 <br>"; // kiíratuk a két változó értékét a függvény meghívása előtt
  hivatkozas($valtozo1, $valtozo2); // meghívjuk a függvényt
  echo "Utána: $valtozo1 és $valtozo2"; //kiíratjuk a két változó értékét a függvény meghívása után
  
  function hivatkozas($szam1, &$szam2) { // két paraméterünk van, az első egy sima paraméter, a második egy hivatkozásos
     // módosítjuk a két változó értékét
     $szam1=555555;
     $szam2=101010;
  }
?>
Code language: HTML, XML (xml)

Eredmény

Előtte: 5 és 10
Utána: 5 és 101010


A fenti példában azért van két változónk, hogy szemléltetni tudjuk, hogyan viselkedik alapértelmezetten egy paraméter és akkor, amikor csak hivatkozunk rá. Az első paraméter értéke csak a függvényben él, ezért hiába módosítjuk a függvény futása során, a függvényen kívül az nem fog élni és módosulni, mert az csak a függvényben élő változó. Azonban a második paraméternél hivatkozást használunk, így valójában nem az értékét adjuk át, hanem annak a változónak a helyét. Így ha a függvényben átírjuk az értékét, akkor valójában nem a függvényben fog megváltozni az értéke, hanem ott ahol létrehoztuk. Így a függvény futása után is megmarad a módosított értéke.

Ha hasznos volt számodra, akkor kérlek oszd meg másokkal is, hogy ezzel támogass minket!