DarCas Sandbox

La programmazione ad oggetti in PHP, con la versione 5, ha subito un notevole potenziamento.

Tra le implementazioni più interessanti, ci sono i metodi magici. I metodi magici sono funzioni che vengono evocante implicitamente al verificarsi di un evento.

Analizziamoli uno per uno, spiegandone la funzionalità e vedendo praticamente come utilizzarli.

__construct

Ogni classe che si rispetti la si instanzia o, volendo utilizzare una terminologia grezza, la si costruisce.

Precedentemente alla versione 5 di PHP, per istanziare una classe occorreva creare una funzione che avesse lo stesso nome della classe. Con PHP 5, c’è il metodo magico __construct; tutte le operazioni dichiarate all’interno della funzione che porta questo nome saranno eseguite al momento della creazione dell’oggetto.

class foo { function __construct () { $this->var = ‘ciao’; } } $class = new foo;

__destruct

Una volta terminato l’utilizzo di una classe è buona norma distruggerla per evitare di tenere allocate risorse inutili. Molto spesso, all’interno di una classe si eseguono operazioni che allocano ulteriori risorse; ad esempio connessioni a database, a file o a directory allocano risorse di sistema che sarebbe buona norma rilasciare alla fine delle operazioni.

Con PHP 5 tutte le operazioni atte al rilascio delle risorse si possono dichiarare all’interno della funzione magica __destruct, la quale viene evocata al momento della distruzione di un oggetto.

class foo { function __construct () { $this->var = ‘ciao’; } function __destruct () { unset($this->var); } } $class = new foo; unset($class);

__call

Questa funzione magica ha il compito di intercettare richieste ad interfacce non implementate in una classe. In condizioni normali, se evochiamo una interfaccia non implementata in una classe, quest’ultima restituisce una errore. Se invece implementiamo la funzione __call, quest’ultima di incaricherà di intercettare le richieste non implementate.

La funzione implementa due variabili, la prima è l’interfaccia non implementata, la seconda sono tutti gli argomenti passati all’interfaccia.

class foo { private $x = array(1, 2, 3); public function __call ($interfaccia, $argomenti) { echo ""Interfaccia {$interfaccia} evocata:""; var_dump($argomenti); return $this->x; } } $foo = new foo; $a = $foo->test(1, ""2″, 3.4, true); var_dump($a); unset($foo);

__get

Questa funzione magica rientra in quelle definiti di overloading. Lo scopo delle funzioni di overloading è quello di “sovrascrivere” un comportamento standard con uno personalizzato.

Implementato la funzione __get, andremo a modificare il normale comportamento che ha il PHP quando evochiamo una determinata variabile.

class foo { public $n; private $x = array(""a"" => 1, ""b"" => 2, ""c"" => 3); public function __get ( $nome_variabile ) { if (isset($this->x[$nome_variabile])) return $x[$nome_variabile]; else echo ""La variabile non esiste!""; } } $foo = new foo; echo $foo->a; unset($foo);

__set

Come per la funzione magica __get, anche la funzione __set è di overloading. Viene evocata quando si esegue una operazione di assegnazione su di una variabile.

class foo { public $n; private $x = array(""a"" => 1, ""b"" => 2, ""c"" => 3); public function __set($nome_variabile, $valore) { if (isset($this->x[$nome_variabile])) $this->x[$nome_variabile] = $valore; else echo ""La variabile non esiste!""; } } $foo = new foo; $foo->a = 10; unset($foo);

__isset e __unset

Gli ultimi due metodi della serie overloading sono questi (al momento, ndr.). Sovrascrivono il comportamento delle funzioni omonime del PHP.

class foo { private $x = array(""a"" => 1, ""b"" => 2, ""c"" => 3); private function __isset ($nome_variabile) { echo ""Controllo se {$nome_variabile} esiste""; return isset($this->x[$nome_variabile]); } private function __unset ($nome_variabile) { echo ""Cancello la variabile {$nome_variabile}""; unset($this->x[$nome_variabile]); } } $foo = new foo; isset($foo->a); unset($foo->a); unset($foo);

__sleep e __wakeup

Questi due metodi magici vengono evocati quando si esegue, rispettivamente, l’operazione serialize e unserialize.

La funzione magica __sleep è utile per liberare risorse che altrimenti sarebbero tenute inutilmente attive.

La funziona magica __wakeup invece permette di ripristinare quest’ultime al momento della de serializzazione dell’oggetto.

class foo { protected $link; private $server, $username, $password, $db; public function __construct ($server, $username, $password, $db) { $this->server = $server; $this->username = $username; $this->password = $password; $this->db = $db; $this->connect(); } private function connect () { $this->link = mysql_connect($this->server, $this->username, $this->password); mysql_select_db($this->db, $this->link); } public function __sleep () { return array('server', 'username', 'password', 'db'); } public function __wakeup () { $this->connect(); } }

__toString

Una classe è un tipo di dati non lineare, ma complesso. Stampare il contenuto di una variabile è un operazione impossibile, se non si prevede una funzione apposita.

Con la funzione __toString si ovvia a questo problema, in quanto questa viene evocata ogni qual volta si decide di stampare l’oggetto.

class somma { private $a; private $b; public function __construct ($a, $b) { $this->a = $a; $this->b = $b; } public function __toString() { return (string) $this->a + $this->b; } } echo new somma(10, 12);

__clone

Molto spesso si ha l’esigenza di clonare un oggetto. Ma non sempre si desidera una esatta copia dell’oggetto; o più semplicemente si vogliono eseguire particolari operazioni ogni qual volta si esegue una clonazione di un oggetto.

Con la funzione __clone, che viene evocata ogni qual volta si esegue una clonazione di un oggetto, possiamo definire tutte le operazioni che riteniamo necessarie.

class SubObject { static $instances = 0; public $instance; public function __construct () { $this->instance = ++self::$instances; } public function __clone () { $this->instance = ++self::$instances; } } class MyCloneable { public $object1; public $object2; function __clone () { $this->object1 = clone $this->object1; } } $obj = new MyCloneable(); $obj->object1 = new SubObject(); $obj->object2 = new SubObject(); $obj2 = clone $obj; print(""Original Object:\n""); print_r($obj); print(""Cloned Object:\n""); print_r($obj2);

__autoload

Questo metodo magico è straordinariamente geniale ed utile. È stato aggiunto per tutti quegli sviluppatori che hanno l’abitudine (ottima, IMHO) di salvare ogni singola classe in un file di testo a se stante avente come nome, il nome della classe stessa.

Con questa funzione magica, il file sarà caricato solo quando la classe viene evocata, snellendo così la fase di interpretazione del codice PHP 5. In effetti, ogni volta che istanzieremo una classe, se una funzione __autoload è stata dichiarata, quest’ultima sarà evocata e si preoccuperà di eseguire le operazioni all’interno dichiarate. La funziona implementa una variabile che è il nome della classe evocata.

function __autoload ($class_name) { require_once(""{$class_name}.php""); } $class = new foo;

Le funzioni magiche, come abbiamo potuto constatare, offrono uno strumento molto potente per realizzare applicazioni solide. Anche noi, tuttavia, possiamo contribuire a rendere solide le nostre applicazioni.

Una buona regola è quella di evitare di creare funzioni all’interno di oggetti che inizino con “__” (doppio underscore, ndr.), questo perché in qualsiasi momento, con l’aggiornarsi del linguaggio, potrebbero essere implementati nuovi metodi magici che potrebbero essere in conflitto con le nostre interfacce.

Per un costante aggiornamento rifarsi alla guida ufficiale Classes and Objects di Zend PHP.