Webstack
Bejelentkezés

Elfelejtetted a jelszavad?

Nem vagy még tag? Kattints ide és regisztrálj most!

PHP Magic metódusok avagy különleges tagfüggények - 1.rész

PHP | tomizej  | 2013-02-02 06:27:13

A PHP osztályai bizonyos metódusokat különleges visszahívható függvények számára tartanak fenn, amelyek bizonyos eseményeket kezelnek. Ezek a metódusok „__" prefixxel kezdődnek.

Jelenleg a magic metódusok: __construct(), __destruct(), __call(), __callStatic(), __get(), __set(), __isset(), __unset(), __sleep(), __wakeup(), __toString(), __invoke(), __set_state() és __clone().

Ilyen nevű függvényeket csak akkor használhatunk az osztályokon belül, ha a hozzájuk kapcsolt speciális funkcionalitást akarjuk megszerezni.

 

Kostruktor, Destruktor

__construct()

A __construct() nevéből is adódóan az osztály konstruktorát jelenti. Az objektum példányosításakor a konstruktor automatikusan meghívódik. A példányosítás eseménye váltja ki ennek a magic metódusnak a meghívását.

A konstruktorokról bővebben itt olvashatunk: http://www.dynamicart.hu/blog/konstruktor-letrehozasi-minta.html

class Car {
    protected $color;    
    public function __construct($color) {
        $this->type = $type;
    }
}
$bmw = new Car('fekete');

A fenti kódban látható hogyan példányosíthatjuk az autó osztályt, illetve hogyan adhatunk át paramétert.

__destruct()

A __destruct() az objektum megsemmisítésért felelős visszahívható metódus, magyarul destruktor. A PHP a referencia számlálás elvére épül, tehát ha a referenciaszámláló elérte a nullát (nincs hivatkozó változó, ami már erre a memóriacímre mutat), akkor a Garbage Collector (GC) megsemmisíti az objektumot. Ekkor hívódik meg a __destruct() metódus még utoljára. Ez a megsemmisítő függvény az osztályok által lefoglalt erőforrások felszabadítására használhatóak (adatbázis kapcsolatok, file leírok...), vagy az objektum utolsó állapotának mentésére.

Megjegyzés:

A destruktor létrehozásnak a PHP nyelvben weboldalak programozásánál legtöbb esetben nem sok értelme van, mivel a kérelmek végén az erőforrások felszabadulnak. Az objektumok addig élnek még egy kérelem ki lesz szolgálva, azaz egy PHP-ból kiszolgált weboldalt betöltünk a böngészőben, bejelentkezünk, keresünk... Viszont hosszú ideig futó önálló PHP programok, vagy nagyszámú állományt feldolgozó folyamatok esetén szükséges és sokszor nem elfelejthető az explicit destruktor hívás.

class User {
    protected $username;
    protected $email;
    
    public function __construct($username, $email) {
        $this->username = $username;
        $this->email = $email;
    }
    
    public function __destruct() {
        echo $this->username. ' megsemmisült';
    }
    
}

Mező túlterhelés (Property Overloading)

A PHP nyelvben a propertyket kicsit más megközelítésből kell felfogni mint más nyelvekben. A túlterhelő metódusok akkor hívódnak meg, ha olyan mezőhöz, szeretnénk hozzáférni ami nem elérhető, vagy nem is létezik(protected, private). A PHP nyelvben minden osztálynak globális túlterhelő metódusai vannak: __get, __set, __isset(), __unset().

__get()

A __get() metódus akkor hívódik meg ha olvasás céljából szeretnénk hozzáférni egy olyan mezőhöz ami nem létezik, vagy nem elérhető. Egy paramétert vár, ami a mező neve stringben megadva. Annak a mezőnek az értékével kell visszatérnie, amit paraméterül kapott. Egy globális getter -nek is felfogható.

Az alábbi kód részletben látható hogyan tudjuk megkapni  egy védett mező értékét, ha kívülről szeretnénk elérni.

class Human {
    protected $name = "Lajos" ;
    public function __get($name) {
        return $this->$name;
    }
}

Fontos megjegyezni, hogy a __get() csak abban az esetben fut le, ha nem elérhető a kért property. Egy publikus property kiolvasása esetén közvetlen elérjük, nincs túlterhelés.

__set()

A __set() metódusnak a meghívására akkor kerül sor, ha írás céljából szeretnénk hozzáférni egy nem elérhető propertyhez. Két paramétere van, $name, $value. Amely a beállítandó property neve és értéke. Egy globális setter -nek is felfogható.

class Human {
//...
    public function __set($name, $value) {
        return $this->$name = $value;
    }
//…
}
$lajos = new Human();
$lajos->name = "Béla";

echo $lajos->name;

__isset()

Az __isset() metódus akkor hívódik meg, ha egy olyan propertyre híjuk meg az isset() függvényt, ami nem elérhető. Egy paraméteres, hasonlóan, mint az isset, a property nevét várja stringben. Visszatérési értéke boolean kell, hogy legyen. Tehát, hogy létezik-e a property.

class Human {
//…
    public function __isset($name) {
        return isset($this->$name);
    }
//…
}

$lajos = new Human();
if (isset($lajos->name)) {
    echo "Van ilyen mező";
}

__unset()

Az __unset() metódus meghívása akkor történik, ha egy olyan propertyt szeretnénk megsemmisíteni az unset() függvénnyel, ami nem létezik. Egy paramétert vár, a property nevét.

class Human {
//…
    public function __unset($name) {
        return isset($this->$name);
    }
//…
}

$lajos = new Human();
unset($lajos->color);

Metódus túlterhelés (Method overloading)

A PHP a metódus túlterhelés is támogatja, ami azt jelenti, ha olyan metódust próbálunk hívni, ami nem létezik, vagy nem elérhető, akkor egy visszahívható metódus hívódik meg (overloading).

__call()

Ha egy objektumon olyan metódust próbálunk hívni, ami nem létezik, helyette a __call() hívódik meg. Két paraméteres, az első a metódus neve, a második pedig az argumentumok.
Első sorban védekezésre használható, ha nem létező metódus hívása történik, ne álljon meg a program futása.
A __call() még kifejezetten hasznos távoli eljárás hívásoknál (RPC), ahol nem biztos, hogy teljes egészében ismerjük a távoli kiszolgáló által implementált metódusokat

Példa egy __call() kezelőre:

class ShoppingCart {
//…
    public function __call($name, $args) {
        echo "A $name metódus nem létezik. paraméterek:".print_r($args,1);
    }
//…
}
$cart = new ShoppingCart();
$cart->helloWolrd();

Illetve programozás technológiai jelentősége is van, ha objektum összetételt alkalmazunk, az olyan metódus hívásokat, melyek nálunk közvetlen nem léteznek, átruházhatjuk egy becsomagolt osztályra.

__callStatic()

A __callStatic() metódus ugyanazzal a funkcionalitással bír, mint a __call(), annyi különbséggel, hogy a nevéből is adódóan ez csak osztály szintű metódusokra vonatkozik. Tehát abban az esetben kerül meghívásra, ha olyan statikus metódust hívunk egy osztályon, ami nem létezik, vagy nem elérhető.

class ShoppingCart {
//…
    public function __callStatic($name, $args) {
        echo "A $name metódus nem létezik. paraméterek:".print_r($args,1);
    }
//…
}

 

 

Szerző: tomizej

címkék
Címkék: tutorial, php,

Hozzászólások

Hozzászóláshoz be kell jelentkezni!

Keress minket Facebookon
Ajánlások