PHP 5 ci fornisce un supporto aggiuntivo per potenziare le nostre classi attraverso la definizione di determinati metodi detti Metodi Magici, in quanto sono nativi di PHP e non è possibile dichiararne di propri con lo stesso nome (riservati).

Vediamo subito una lista di questi metodi e i servizi che offrono :

• __toString() - Metodo per restituire l'oggetto sotto forma di stringa
• __set() - Permette l'overloading per assegnare un valore ad un attributo
• __get() - Consente l'overloading delle istruzioni di lettura di un attributo
• __isset() - Overloading del metodo isset() per gli attributi di una classe (disponibile da PHP 5.1.0)
• __unset() - Overloading del metodo unset() per gli attributi di una classe (disponibile da PHP 5.1.0)
• __call() - Permette l'overloading dei metodi di una classe
• __clone() - Consente l'overloading per la clonazione degli oggetti
• __autoload() - Funzione per l'auto-inclusione di file per classi non ancora definite
• __sleep() - Richiamato subito prima di una serializzazione di un oggetto
• __wakeup() - Richiamato subito dopo una serializzazione di un oggetto
• __set_state() - Metodo statico richiamato per le classi esportate con var_export() (disponibile da PHP 5.1.0)

Overload di __toString()

Prototipo della funzione :

string __toString()

<?php

	class Persona
	{
		private $nome;
		private $cognome;

		public function Persona($n, $c)
		{
			$this->nome = $n;
			$this->cognome = $c;
		}

		public function __toString()
		{ return $this->nome . " " . $this->cognome; }
	}

	$obj = new Persona("John", "Doe");
	echo $obj; // Stampa "John Doe"

	$stringa = "Ciao sono " . $obj;
	echo $stringa; // Stampa "Ciao sono John Doe"

?>

Nota : Prima di PHP 5.2.0, __toString() veniva chiamato solo in combinazione con echo e print.

Nei capitoli a seguire vedremo nel dettaglio l'overload degli altri Metodi Magici sopra elencati.

Abbiamo visto nei capitoli precedenti, che l'istruzione throw quando solleva un'eccezione solleva in realtà un oggetto della classe Exception.

PHP ci consente inoltre di sollevare delle eccezioni proprie, attraverso la creazione di sottoclassi specifiche che devono obbligatoriamente essere derivate dalla built-in Exception.

A questo proposito vedremo come sarà possibile annidare più blocchi catch ad un blocco try, similmente ad una struttura di controllo classica come la IF - ELSE IF, che ci consentirà di controllare che tipo di eccezione è stata sollevata e agire di conseguenza.

Illustrerò ora un esempio analogo a quello spiegato nel capitolo Gestione degli Errori, inserendo però una classe aggiuntiva per gestire le eccezioni sugli input utente, lasciando la classe Exception per le altre eccezioni non previste.

Esempio eccezioni personalizzate

<?php

	class Utente
	{
		public $nome_utente;
		public $pass_utente;

		public function Utente($n, $p)
		{
			if (strlen($n) > ErroriUtente::MAX_LUNGHEZZA)
			    throw new ErroriUtente($n);

			if (strlen($p) > ErroriUtente::MAX_LUNGHEZZA)
			    throw new ErroriUtente($p);

			$this->nome_utente = $n;
			$this->pass_utente = $p;
		}
	}

	class ErroriUtente extends Exception
	{
		const MAX_LUNGHEZZA = 20;

		private $errore;

		public function ErroriUtente($stringa)
		{
			$this->errore = "Errore : La lunghezza massima consentita è " . self::MAX_LUNGHEZZA;
			$this->errore .= "\n<br />\"$stringa\" è di " . strlen($stringa) . " caratteri!";
		}

		private function stampaLink($pagina = "registrazione.php")
		{
			echo "<a href=\"$pagina\">Torna indietro</a> per reinserire i dati.";
		}

		public function stampaMessaggio($link = false)
		{
			echo $this->errore . "<br /><br />\n\n";

			if ($link) $this->stampaLink();
		}
	}
	
	function registraUtente(Utente $utente)
	{
		// ... codice per registrare l'utente nel database

		$registrato = true; // Simuliamo una registrazione avvenuta con successo

		if ($registrato)
			echo "Utente registrato con successo!";
		else
			throw new Exception("Impossibile registrare l'utente, riprova più tardi!");
	}

	try
	{
		$utente = new Utente("Amircare", "supercalifragilistichespiralidoso");

		registraUtente($utente);
	}
	catch (ErroriUtente $e)
	{
		$e->stampaMessaggio(true);
	}
	catch (Exception $e)
	{
		echo $e->getMessage();
	}

?>

Il codice produce questo risultato.

Analisi del codice

Suggerimenti sulle eccezioni

Ricordatevi che non sempre è necessario definire un costruttore per la vostra sottoclasse di Exception, se PHP non lo troverà effettuerà automaticamente una chiamata al costruttore della classe madre, ossia Exception.

Inoltre usate questo sistema solo per gestire le eccezioni, per risolvere quindi quei problemi imprevisti che si presume non accadano poi così spesso.

Non utilizzate assolutamente la gestione delle eccezioni come una sruttura di controllo, non solo per un discorso di performance (le eccezioni sono più lente), ma anche per mantenere il codice il più robusto e leggibile possibile, evitando problemi di manutenzione futuri.

Infine prestate attenzione al tipo di eccezioni che gestite in determinati blocchi try / catch, poichè con questo sistema se catturate un eccezione anche molto grave, non interromperete lo script, e il codice successivo sarà quindi eseguito :

<?php

	function sollevaEccezione()
	{ throw new Exception("Eccezione grave!"); }

	function registraUtente()
	{ /* Codice per registrare un'utente */ }

	try
	{
		sollevaEccezione();
	}
	catch (exception $e)
	{
		echo $e->getMessage() . "<br />\n";
	}

	try
	{
		echo "Codice d'esempio che non andrebbe eseguito in caso di eccezioni gravi!";
		registraUtente();
	}
	catch (exception $e)
	{
		echo $e->getMessage();
	}

?>

L'esempio produrrà in output :

Eccezione grave!
Codice d'esempio che non andrebbe eseguito in caso di eccezioni gravi!

E' buona norma quindi minimizzare la quantità di blocchi try / catch e se necessario annidateli.

Teoria sulle Eccezioni

Come abbiamo visto nel capitolo Strutture di controllo, al verificarsi di una situazione inaspettata, quindi di un errore dal momento che l'applicazione non è stata programmata per produrre quello stato, è possibile interrompere lo script con le istruzioni exit e die.

Così facendo però non si ha una gestione dell'errore intelligente ma una drastica terminazione dello script.

Per essere precisi, il termine esatto per definire questi eventi inaspettati che si verificano durante l'esecuzione dello script, è Eccezioni.

Un evento imprevisto, un baco nello script, la perdita di una connessione al Database, sono tutte considerate eccezioni che PHP ci consente di gestire attraverso tre comandi molto semplici :

• throw - Solleva un'eccezione
• try - Se si verifica un'eccezione nel codice del blocco try, quest ultimo fa saltare l'esecuzione del codice al blocco catch
• catch - Contiene il codice alternativo che viene eseguito al verificarsi dell'eccezione

Esempio di gestione errori

Nell'esempio che segue vedremo del codice che ha come compito il controllo dei dati di un utente.
Se i dati vengono ritenuti adeguati si procede alla registrazione nel database, altrimenti si notifica l'errore all'utente, mettendogli a disposizione un link per tornare indietro a reinserire i dati.

Il codice essendo solo dimostrativo, considera i dati non validi se superano una certa lunghezza, e rimanda l'utente ad una ipotetica pagina di registrazione chiamata registrazione.php :

<?php

	define("MAX_LUNGHEZZA", 20);

	function registraUtente()
	{
		// ... codice per registrare l'utente nel database

		$registrato = true; // Simuliamo una registrazione avvenuta con successo

		if ($registrato)
		    echo "Utente registrato con successo!";
		else
		    throw new Exception("Impossibile registrare l'utente!");
	}

	/* --- Inizio dati Utente --- */

	$nome_utente = "Agamennone";
	$pass_utente = "supercalifragilistichespiralidoso";

	/* --- Fine dati Utente --- */

	try
	{
		if (strlen($nome_utente) > MAX_LUNGHEZZA)
		    throw new Exception("Nome utente troppo lungo!");

		if (strlen($pass_utente) > MAX_LUNGHEZZA)
		    throw new Exception("Password troppo lunga!");

		registraUtente();
	}
	catch (Exception $exc)
	{
		echo "Errore : " . $exc->getMessage() . "<br />\n\n";
		echo "<br /><a href=\"registrazione.php\">Torna indietro</a> per reinserire i dati.";
	}

?>

Il codice soprastante produce questo risultato.

Osservazioni sulle eccezioni

Come avrete notato dall'ultimo esempio, quando throw solleva un'eccezione, manda al dovuto blocco catch un'istanza della classe Exception, nativa di PHP.

Throw quindi, utilizza new per creare una nuova istanza, e a seguire il costruttore di Exception con un messaggio opzionale per inizializzarne l'istanza.

La suddetta istanza viene poi catturata da catch, che si serve del metodo "getMessage()" per leggere il messaggio inviatogli da throw e gestire l'eccezione come programmato.

Nota : Se viene sollevata un'eccezione al di fuori di un blocco try / catch, questa interromperà lo script con un errore fatale :
Fatal error: Uncaught exception ...