E' buona pratica nella programmazione orientata agli oggetti, avere un file per la dichiarazione di ogni classe, ognuno nominato con lo stesso identico case usato per il nome della classe.

Questo ci consente di trovare immediatamente il codice di una classe, e di apportarvi modifiche immediatamente disponibili in tutti i sorgenti che utilizzano tale classe, facendoci risparmiare molto tempo durante la manutenzione del codice.

Questo metodo ci consentirà anche di farci risparmiare molte righe di codice perchè ci da la possibilità di includere esclusivamente le classi che realmente sono necessarie per la corretta esecuzione dello script.

In applicazioni reali però, diventa problematico inserire in ogni file dello script decine e decine di righe di inclusioni di file esterni, e a questo proposito PHP ci mette a disposizione la funzione Magica __autoload().

Esempio con __autoload()

ClasseUno.php

<?php

	class ClasseUno
	{
		public $attributo = "Attributo di Classe Uno";
	}

?>

ClasseDue.php

<?php

	class ClasseDue
	{
		public $attributo = "Attributo di Classe Due";
	}

?>

test.php

<?php

	function __autoload($classe)
	{
		require_once("$classe.php");
	}

	$obj = new ClasseUno();
	echo $obj->attributo . "<br />\n";

	$obj = new ClasseDue();
	echo $obj->attributo;

?>

Come potete notare dalla pagina test.php, non ho esplicitamente incluso i file esterni ClasseUno.php e ClasseDue.php, ma ci ha pensato la funzione __autoload() richiamata automaticamente da PHP che non ha trovato subito le dichiarazioni delle classi.

Nota : fate attenzione a non specificare più di una funzione __autoload() per script o riceverete un errore fatale.

Fatal error : Cannot redeclare __autoload() (previously declared in C:\AppServ\www\test\test.php:3)

Inoltre i nomi delle classi in PHP sono case-insensitive, mentre __autoload() li gestisce come sensitive, perciò prestate molta attenzione a quando nominate i file, che come dicevo all'inizio è buona norma che siano identici al nome della classe.

Prototipi di __isset() e __unset()

bool __isset (string name)
void __unset (string name)

Effettuando un overloading su questi due metodi magici, abbiamo la possibilità di controllare quando vengono effettuate delle chiamate alle funzioni isset() e unset() (descritte qui) su un attributo della classe.

Anche in questo caso, le chiamate vengono effettuate solo per attributi non accessibili o non dichiarati.

Il metodo __isset() viene richiamato anche per l'overload su empty() :

<?php

	class Oggetto
	{
		private $privato;
		public $pubblico;

		public function __isset($attributo)
		{
			echo "<br />Chiamata a __isset() da \"$attributo\" = ";

			switch ($attributo)
			{
				case "privato" :
					return isset($this->privato);
					break;

				case "pubblico" :
					return isset($this->pubblico);
					break;

				default :
					throw new Exception("Attributo non esistente");
					break;
			}
		}

		public function __unset($attributo)
		{
			echo "<br />Chiamata a __unset() da \"$attributo\"";
			unset($attributo);
		}
	}

	try
	{
		$obj = new Oggetto();

		echo (int) isset($obj->pubblico);
		echo (int) isset($obj->privato);
		echo (int) empty($obj->privato);

		unset($obj->bho);
		echo (int) isset($obj->nonesisto);
	}
	catch (Exception $e)
	{ echo $e->getMessage(); }

?>

Analizziamo il codice nel blocco try :

• Prima echo : non provoca chiamate al metodo magico __isset() ma direttamente alla funzione standard isset() perchè l'attributo Oggetto->pubblico è accessibile (public)
• Seconda echo : provoca una chiamata a __isset() che ritorna false da isset($this->privato); poichè $privato non è stato inizializzato
• Terza echo : provoca una chiamata a __isset() che ritorna true perchè $privato non è stato inizializzato (quindi è vuoto)
• unset() : provoca una chiamata a __unset() che stampa ("Chiamata a __unset() da "bho"")
• Quarta echo : provoca una chiamata a __isset() che solleva un'eccezione ("Attributo non esistente")

Nota : nelle echo viene effettuato il casting esplicito al tipo int, perchè se echo riceve il valore booleano false non stampa nulla.

Inoltre fate attenzione alla versione di PHP che utilizzate perchè l'overloading di queste funzioni è disponibile solo da PHP 5.1.0

Overload di __set()

Prototipo della funzione :

void __set (string name, mixed value)

Esempi di overloading

<?php

	class Oggetto
	{
		public function __set($attributo, $valore)
		{ /* Corpo funzione */ }
	}

	$obj = new Oggetto();
	$obj->pippo = 32;

?>

L'ultima riga di codice quindi ($obj->pippo = 32), corrisponde ad una chiamata al metodo __set() con questi parametri : __set("pippo", 32);
Questo accade perchè nella definizione della classe "Oggetto", non abbiamo dichiarato nessun attributo di nome "pippo".

Vediamo un esempio più complesso :

<?php

	class Stringa
	{
		private $stringa;
		const MAX_CHARS = 15;

		public function Stringa($valore)
		{
			if (strlen($valore) > self::MAX_CHARS)
			{ throw new Exception("Stringa troppo lunga (max " . self::MAX_CHARS . " car.)"); }
			else
			{ $this->stringa = $valore; }
		}

		public function __set($attributo, $valore)
		{
			if ($attributo == "stringa")
			{ self::Stringa($valore); }
			else
			{ throw new Exception("Attributo non esistente!"); }
		}

		public function __toString()
		{ return $this->stringa; }
	}

	try
	{
		$obj = new Stringa("Ciao ciao!!!");
		echo "$obj<br>\n"; // Stampa "Ciao ciao!!!"

		$obj->stringa = "Ancora ciao!";
		echo "$obj<br>\n"; // Stampa "Ancora ciao!"

		$obj->stringa = "Un ultimo saluto!";
		echo "$obj<br>\n"; // Solleva un'eccezione con il messaggio : "Stringa troppo lunga (max 15 car.)"

	}
	catch (Exception $e)
	{
		echo $e->getMessage();
	}

?>

Il questo modo avremo la sicurezza che venga sempre effettuato un casting esplicito di tipo float durante l'assegnazione dei valori, e risparmieremo inoltre righe di codice durante la gestione degli pseudo-attributi potendo utilizzare una semplice foreach per scorrerli tutti, creando del codice rapido e più flessibile.

<?php

	// Inizio dichiarazione Classe
	class Coordinata
	{
		private $xyz;

		public function Coordinata($x, $y, $z)
		{
			$this->xyz = array();

			$this->xyz["x"] = (float) $x;
			$this->xyz["y"] = (float) $y;
			$this->xyz["z"] = (float) $z;
		}

		public function __set($attributo, $valore)
		{
			switch ($attributo)
			{
				case "x" :
				case "y" :
				case "z" :
					$this->xyz[$attributo] = (float) $valore;
					break;
				default :
					throw new Exception("Attributo non valido!");
					break;
			}
		}
		
		public function __toString()
		{
			$return = "";

			foreach ($this->xyz as $chiave => $valore)
				$return .= "$chiave = $valore<br />\n";

			$return .= "<br>\n";

			return $return;
		}
	}
	// Fine dichiarazione Classe

	try
	{
		$punto = new Coordinata(15, 17.3, 22.4);

		echo $punto;

		$punto->x = 20.3;
		$punto->z = 11.2;

		echo $punto;

		$punto->a = 22.1; // L'attributo "a" non esiste e sarà sollevata un'eccezione
	}
	catch (Exception $e)
	{ echo $e->getMessage(); }

?>

Il codice soprastante produrrà questo risultato.