9.08. Függvények, paraméterek átadása, változók láthatósága

Eddig sok szó esett a változókról és esetenként a függvényekről is, azonban az eddigiek alapján azt gondolná az ember, hogy csak ilyen egyszerű programok írhatók PHP-ban. Az igazság az, hogy PHP-ban csak a futási idő és a futtató rendszer memóriája szab határt az alkalmazott program bonyolultságának.

Függvények / Eljárások

A PHP-ban is használhatunk programstruktúrákat, programszegmenseket. Már Pascal-ból vagy C-ből, C#-ból is jól ismerhetjük az alapvető két eljárástípust, amit Pascalban Procedure illetve Function névvel illetünk, C-ben pedig típus nélküli illetve típusos function-nak mondunk. Mind a két nyelven a különbség az, hogy ad-e vissza a kérdéses eljárás értéket, vagy nem.

A PHP-ben is kétféle eljárás típust használhatunk. A szintaktika a következő:

Ez az eljárástípus nem ad vissza értéket.

function függvény_név(paraméterlista) {
   A függvény törzse;
}

Ez az eljárástípus a definiáltnak megfelelő típusú értéket ad vissza:

function függvény_név(paraméterlista) {
    A függvény törzse;
    return érték;
}

Látható, hogy a visszatérési érték léte vagy nem léte a programozótól függ, ezért egyes esetekben célszerű a visszatérési érték típusát megállapítani ahhoz, hogy van-e egyáltalán visszatérési érték.

Rekurzió lehetséges a függvényhívásoknál, de természetesen arra kell vigyázni, hogy a rekurzió véget érjen. Az alábbi kis példa az N faktoriális kiszámítását végzi rekurzív módon.

function nfakt($n){
    if ($n>1) $nf = $n*nfakt($n-1);
    else $nf = 1;
 
    echo $n." => ".$nf."<BR>";
    return $nf;
}

nfakt(200);

Paraméterátadás

Egy függvény definiálásakor meg kell határozni, hogy milyen paramétereket vegyen át. Ezt a formális paraméterlistával tudjuk megtenni, amelyben az átvevő változók neveit vesszővel elválasztva fel kell sorolni.

A híváskor nem kell minden paramétert átadni. A függvény formális paraméterlistájában default értéket is lehet adni a paraméternek.

A PHP-ben kétféle paraméterátadás, létezik

Érték szerinti

A hívó kifejezés értéke behelyettesítődik a meghívott függvény paraméterlistájában szereplő változóba és a függvényen belül a paraméter használható. Ez az alapértelmezés.

Cím szerinti

Ez azt jelenti, hogy a változó memóriacímét adjuk át a függvénynek, amely a cím ismeretében tudja azt módosítani és a függvényből való visszatéréskor a változások megmaradnak.

Ez utóbbi esetben, ha cím szerint akarunk átvenni értéket egy függvénnyel, akkor használnunk kell a & operátort.

  function fgv(&$n) {
    $n *= 2;
  }

  $n=100;
  echo ”$n<BR>”;
  fgv($n);
  echo ”$n<BR>”;

  function joghurtot_keszit ($flavour, $type = "acidophilus") {
    return "Készítek egy köcsög $flavour ízű $type-ot.\n";
  }

  echo joghurtot_keszit ("eper");

Ha azt szeretnénk, hogy egy függvény változó számú paramétert vegyen át és a függvényben meg akarjuk állapítani, hogy éppen most hány paraméter van, akkor a következő függvényeket használni:

func_get_args() - Egy tömbben visszaadja az átadott paraméterek listáját.

func_num_arg() - Megadja a kapott függvények számát

func_get_arg(sorszám) - Visszaadja a sorszám paraméterrel megadott paramétert. Ha a sorszám nagyobb, mint a paraméterlista utolsó elemének indexe, akkor hibaüzenet jön (warning). A paraméterlista indexe 0-val kezdődik.

Az alábbi példa ezeket példázza.

function foo() {
    $numargs = func_num_args();
    echo "paraméterek száma: $numargs<br>\n";

    if ($numargs >= 2) {
        echo "A második paraméter: " . func_get_arg (1) . "<br>\n";
    }

    $arg_list = func_get_args();
    for ($i = 0; $i < $numargs; $i++) {
        echo "$i-ik paraméter: " . $arg_list[$i] . "<br>\n";
    }
} 

foo (1, 2, 3);

Egy függvény tetszőleges típust, még tömböt, vagy változóreferenciát is vissza tud adni. Több érték visszaadására a tömböt használhatjuk.

Változók élettartalma és láthatósága

A PHP-ban nagyon egyszerű szabályok vannak a változók láthatóságára és élettartamára vonatkozólag.

Élettartam

A változó akkor jön létre, amikor létrehozzuk, értéket adunk neki. Egy változó megsemmisül, ha az unset(változónév) paranccsal felszabadítjuk a változó nevét (memóriaterületét is), vagy véget ér az adott PHP script oldal. Ez alól kivétel, ha a változókat átadjuk egy másik PHP oldalnak a POST, GET metódussal, a cookie-k vagy sessionok használatával.

Egy PHP minden részén használhatók a $_POST, $_GET, $_SESSION, $_COOKIE, $_ENV, $_SERVER, $GLOBALS tömb elemei. Ezek a szuperglobális változók.

Globális változók

Ha függvényben szeretnénk őket használni, akkor használni kell a globals kulcsszót és használhatjuk a függvényen belül. pl.

  $x = 111;
  
  function pelda(){
      globals $x;
      print $x;
  }

Létezik-e a változó

Azt, hogy egy változó létezik-e az isset() függvénnyel kérdezhetjük le. Igazat ad vissza, ha a változó létezik, az empty() függvény pedig igazat ad vissza, ha a változó értéke 0, üres, vagy nem létezik!

    if (!isset($_SESSION[”logged_in”])) die(”Jelentkezz be!”);
    print(”Beléptél!”);

A PHP oldalon létrejött, a fő oldalon definiált változók globálisak, azaz attól a helytől kezdve láthatók mindenhonnan.

Egyébként ha meghívunk egy függvényt, akkor abban a függvényben csak azok a változók láthatók, amelyeket a függvényben hoztunk létre, vagy paraméterként adtunk át. Ha a függvényből kilépünk, akkor ezek a változók megsemmisülnek kivéve, ha cím szerinti paraméterátadás során jöttek létre. Azaz ezek a változók lokálisak lesznek a függvényre nézve.

Ha egy függvényből új függvényt hívunk, akkor abban nem lehet látni a hívó függvény változóit.

A fentiek alól az egyetlen kivétel, ha a függvényben használjuk a global parancsot, aminek segítségével importálhatjuk a script globális változóit a függvénybe.

    $a = 1;
    $b = 2;
 
    Function Osszead () {
          global $a, $b;
          $b = $a + $b;
    } 

    Ossszead ();
    echo $b;

    $b = 1;
    $a = 10;
    $GLOBALS["b"] = $GLOBALS["a"] + $GLOBALS["b"];
    echo $b;

Statikus változó egy függvényben jöhet létre. Amikor kilépünk a függvényből már nem használhatjuk ennek a változónak az értékét, de ha újra meghívjuk a függvényt, akkor még megvan az előző értéke. Ott folytathatjuk, ahol abbahagytuk. Ennek néha van értelme. Mindenesetre a használatához a függvényben a static kulcsszót kell használni. Az alábbi kis szösszenet egy ciklusból meghívja újra meg újra a Test() függvényt és ennek során az $a változó tartalma folyamatosan nő, noha mindig kilépünk a függvényből, mivel statikusnak deklaráltuk! A statikus változónak kezdőértéket adva, az csak egyszer fut le, amikor először meghívjuk a függvényt.

Function Test () {
    static $a = 0;
    echo $a;
    $a++;
}

for ($i =0; $i< 10;$i++) {
    Test();
    Echo ”blablabla”
}