7.1. fejezet¶

A fejezet anyaga¶

PHP - Függvények¶

Függvénydefiníció, függvényhívás¶

Természetesen PHP-ban is van lehetőségünk arra, hogy saját függvényeket definiáljunk. A függvénydefiníció szintaxisa a következőképpen néz ki:

<?php
  function fuggveny_neve($param1, $param2, ...) {
    // függvénytörzs (utasítások)
  }
?>

Ha egy függvényt meg szeretnénk hívni, akkor ezt a szokásos szintaxissal tehetjük meg.

<?php
  fuggveny_neve(/* paraméterek átadása */);
?>

PHP-ban a globális scope-ban létrehozott függvények már a definiálásuk előtt is meghívhatók. Ez a szelekciós vezérlési ágakon (pl. if-en) belül definiált függvényekre nem vonatkozik, ők ugyanis csak akkor jönnek létre, amikor a vezérlés eljut hozzájuk.

Változók hatóköre¶

PHP-ban a fájlban létrehozott változók a globális scope-ba kerülnek. A függvényeken belül létrehozott változók lokálisak lesznek a függvény törzsében, tehát ezeket nem lehet a függvényen kívülről elérni.

Fontos megjegyezni, hogy PHP-ban a függvényen kívüli (globális) változók alapértelmezett módon nem láthatóak a függvény törzsében.

<?php
  $val = 10;

  function egy_klassz_fuggveny() {
    // $val innen nem elérhető!
  }
?>

Ha egy függvény törzsében el szeretnénk érni egy függvényen kívüli változót, akkor ezt kétféle módon tehetjük meg:

a global kulcsszóval globálisként újradeklaráljuk a változót a függvényben
a $GLOBALS szuperglobális tömb elemeként hivatkozunk a változóra (a szuperglobális tömbökről hamarosan részletesebben tanulunk).

Példa: Függvényen kívüli változó elérése a függvény törzséből

<?php
  $val = 10;

  function globalis_modosit1() {    // 1. módszer: global kulcsszó
    global $val;
    $val = 20;
  }

  function globalis_modosit2() {    // 2. módszer: $GLOBALS szuperglobális tömb
    // a $GLOBALS kulcs-érték párokként tárolja a program globális változóinak nevét és értékét
    $GLOBALS["val"] = 42;   // a "val" nevű globális változó értékét módosítjuk
  }

  globalis_modosit1();          // $val új értéke: 20
  globalis_modosit2();          // $val új értéke: 42
?>

A static kulcsszóval létrehozhatunk statikus változókat is. Ezek a létrehozó blokkon belül (jelen esetben a függvényen belül) lokálisak lesznek, viszont a blokkon kívül is megőrzik az értéküket, így a blokkba visszatérve a korábbi, megőrzött érték újra felhasználható.

Példa: Írjunk egy olyan függvényt, amely kiírja, hogy eddig hány alkalommal hívták meg!

<?php
  function szamol() {
    static $count = 0;   // statikus változó ("megőrzi a korábbi értékét")
    $count++;
    echo "Ezt a függvényt $count alkalommal hívták meg. <br/>";
  }

  szamol();
  szamol();
  szamol();
?>

A kód kimenete

Ezt a függvényt 1 alkalommal hívták meg. Ezt a függvényt 2 alkalommal hívták meg. Ezt a függvényt 3 alkalommal hívták meg.

Paraméterátadás¶

PHP-ban a függvényhíváskor alapértelmezett módon érték szerinti paraméterátadás történik (kivéve objektumok esetén). Ekkor az átadott változónak egy másolatával dolgozunk a függvényen belül.

Ha az eredeti változóval szeretnénk dolgozni a függvényben, akkor referencia szerinti paraméterátadást használunk. Ezt az & (és-jel) operátorral tehetjük meg.

Példa: Érték és referencia szerinti paraméterátadás

<?php
  function modosit1($x) { $x = 42; }      // érték szerinti paraméterátadás
  function modosit2(&$x) { $x = 42; }     // referencia szerinti paraméterátadás

  $val = 10;
  modosit1($val);   // $val értéke továbbra is 10 (hiszen csak egy másolatát módosítottuk)
  modosit2($val);   // $val új értéke 42 lesz
?>

Visszatérési érték¶

Természetesen PHP-ban is lehet a függvényeinknek visszatérési értékük. A függvény által visszaadott érétket a return kulcsszó után adhatjuk meg.

Ha a függvény referenciával tér vissza, akkor a függvény neve elé egy &-jelet írunk mind a függvénydefiníció, mind a függvényhívás helyén.

Példa: Visszatérési érték

<?php
  function osszead($szam1, $szam2) { return $szam1 + $szam2; }
  function &novel(&$szam) { $szam++; return $szam; }      // referenciát visszaadó függvény

  $osszeg = osszead(10, 20);      // $osszeg értéke: 30
  $a = 5;
  $b = &novel($a);    // $a és $b értéke is 6 lesz ($a értéke a referencia szerinti átadás miatt változik)
?>

Default paraméterek¶

A Javával ellentétben PHP-ban nem definiálhatunk a kódban több azonos nevű függvényt (még eltérő paraméterezés esetén sem), különben végzetes hibát kapunk!

A gyakorlatban viszont sokszor felmerül az igény arra, hogy egy függvényt akár eltérő paraméterszámmal is meg tudjunk hívni. Szerencsére a PHP erre is biztosít lehetőséget: a default függvényparamétereket.

A default paraméterek lényege, hogy a függvény bizonyos paramétereinek alapértelmezett értéket adunk a függvénydefiníció során. Ha a függvényhíváskor nem adjuk meg az adott paraméter értékét, akkor az az alapértelmezett értéket veszi fel.

Példa: Default paraméter használata

<?php
  function koszon($nev="Senki") {
    echo "Szia, $nev! <br/>";
  }

  koszon();
  koszon("Tamás");
?>

A kód kimenete

Szia, Senki! Szia, Tamás!

A fenti kódban először paraméter nélkül hívjuk meg a koszon függvényt. Mivel a $nev paraméterváltozónak ekkor nem adunk át értéket, ezért az a "Senki" default értéket veszi fel. A második függvényhívásnál már megadjuk a paraméter értékét ("Tamás"), így ekkor az átadott értéket fogjuk használni a függvényen belül (nem pedig a default értéket).

Egy fontos szabály, amit meg kell jegyeznünk: ha nem minden függvényparaméternek adunk alapértelmezett értéket, akkor mindig az utolsó néhány paraméternek kell default értéket adnunk. Tehát a default paraméterek mindig a paraméterlista jobb oldalán sorakoznak.

Példa: Egy összeadás függvény, amely eltérő paraméterszámmal is meghívható

<?php
  function osszead($a, $b=0, $c=0) { return $a + $b + $c; }

  $x = osszead(5);          // 5 + 0 + 0 = 5
  $y = osszead(5, 2);       // 5 + 2 + 0 = 7
  $z = osszead(5, 2, 3);    // 5 + 2 + 3 = 10
?>

Type hint-ek¶

Gyengén típusos nyelvről lévén szó, a PHP-beli függvények paramétereinek és visszatérési értékének típusa nem kötött. Tehát egy függvény alapból bármilyen típusú paramétereket képes fogadni, és a visszatérési érték is tetszőleges típusú lehet.

A type hint-ek segítségével megadhatjuk a függvényparaméterek és a visszatérési érték elvárt típusát. Ha a kapott típus nem megfelelő, akkor a PHP megpróbálja azt a type hint-tel megadott típusra konvertálni. Ha a konverzió sikertelen, akkor végzetes hibát kapunk.

Példa: Egy átlag függvény, amely két int típusú paramétert vár és egy float értékkel tér vissza

<?php
  function atlag(int $a, int $b) : float {
    return ($a + $b) / 2;
  }

  echo atlag(10, 5) . "<br/>";            // OK, mindkét paraméter int típusú
  echo atlag(3.5, TRUE) . "<br/>";        // OK, mindkét érték int-re konvertálható (3.5 -> 3, TRUE -> 1)
  echo atlag(101, "kiskutya") . "<br/>";  // HIBA! a "kiskutya"-t nem lehet int-re konvertálni!
?>

A kód kimenete

7.5 2 FATAL ERROR Uncaught TypeError: Argument 2 passed to atlag() must be of the type int...

Változó hosszúságú paraméterlista¶

PHP-ban írhatunk olyan függvényeket is, amelyek tetszőleges számú paraméterrel meghívhatók. Ezt a paraméterváltozó elé írt ... operátorral tehetjük meg. Ekkor a függvényhíváskor megadott paraméterek egy tömbként kerülnek átadásra, amit egy foreach szerkezettel egyszerűen bejárhatunk.

Példa: Egy függvény, amely tetszőleges számú, int típusú paramétert képes fogadni

<?php
  function atlag(int ...$szamok) : float {    // változó hosszúságú paraméterlista
    $osszeg = 0;
    foreach ($szamok as $szam) {              // paraméterek bejárása
      $osszeg += $szam;
    }
    return $osszeg / count($szamok);
  }

  $a = atlag(10, 20, 30);                       // 20
  $b = atlag(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);    // 5.5
?>

Utolsó frissítés: 2024-02-10 17:23:02