Des pseudos-tableaux

Il est en effet possible d’utiliser la syntaxe suivante (utiliser des objets comme des arrays):

$m = new Machin;
$m["test"] = 12

Ca peut parraitre bizarre, mais c’est parfois pratique. Voici une petite description de l’utilisation de ce feature:

class Machin implements ArrayAccess {
	//Est-ce que isset($obj[$var] ?
	public function offsetExists($var) {
		return true;
	}
	//Quelle est la valeur de $obj[$var] ?
	public function offsetGet($var) {
		return 42;
	}
	//Définition de la valeur $obj[$var]
		public function offsetSet($var, $val) {
		echo "$var = $val!\n";
	}
	//Appel à unset($var[$obj])
	public function offsetUnset($var) {
		echo "removing $var\n";
	}
}
$m = new Machin;
if (isset($m["toto"])) { //true
	echo $m["toto"]."\n";   //42
	$m["truc"] = "bidule";  //truc = bidule!
	unset($m["blork"]);     //removing blork
}

Il est par exemple plus facile de créer un système de session customizées, enfin, laissez votre imagination tourner je pense que vous aurez bien plus d’idées que moi, sachant que chaque acces au tableau provoque un appel de fonction et peut donc être dynamique (pourquoi pas requêter un SGBD). Il est aussi possible de « mapper » un serveur memcache par exemple, créer une classe qui permettra d’utiliser le serveur de cache comme un simple tableau.

Des objets itérables

Vous qui utilisez des templates php à tour de bras vous devez apprécier fortement l’instruction foreach. Je vous laisse donc découvrir ce que vous pouvez faire en implémentant Iterator:

• function rewind() : retourne à la premiere position de l’itération
• function current() : retourne l’élément courant
• function key() : retourne la clé courante
• function next() : passe à l’élément suivant
• function valide() : retourne vrai si l’élément est valide (permet d’arrêter l’itération)

Il est alors possible de faire:

$trucs = new Trucs;
foreach ($trucs as $t) {
	//Faire quelque chose avec $t
}

Ce qui peut s’avérer pratique lorsque la sémantique de votre objet est justement d’être un containers. Pour plus de détails je vous laisse consulter la documentation.

Appels de méthodes enchaînés

Ce n’est pas vraiment quelque chose d’obscur ou de caché mais plus une astuce. Lorsque vous souhaitez appeller plusieurs fonctions sur le même objet, et que ces fonctions ne retournent rien, rien ne coute d’ajouter un return $this; à la fin de la fonction en question, ce qui vous permet d’enchainer les appels sur la même ligne. Un petit exemple:

class Query {
	private $sql;
	public function __construct() {
		$this->sql = "SELECT * FROM ";
	}
	public function from($table) {
		$this->sql.= "`$table` ";
		return $this;
	}
	public function where($where) {
		$this->sql.= "WHERE $where ";
		return $this;
	}
	public function exec() {
		echo "Requete: ".$this->sql."\n";
	}
}

$q = new Query;
$q->from("users")->where("id=12")->exec();
//Requete: SELECT * FROM `users` WHERE id=12

L’exemple est très caricatural, mais on voit vite les avantages d’un tels procedé. Cette syntaxe est largement utilsiée par certaines libs comme Doctrine.

Les fonctions magiques

Chaque classes définit ses propres méthodes, mais peut aussi définir des méthodes dynamiquement. Lorsqu’une méthode n’existe pas, php appelle la fonction __call() si elle existe. un petit exemple:

class User {
	public function __call($func, $params) {
		if (substr($func, 0, 2) == "by") {
			$name = trim(strtolower(substr($func, 2)));
			$param = $params[0];
			echo "SELECT * FROM users WHERE `$name`=\"".$params[0]."\"";
		}
	}
}
$u = new User;
$u->byName("toto");
//SELECT * FROM users WHERE `name`="toto"

Encore très simplifié, mais je pense que le concept transparait bien, les fonctions peuvent être parfois plus parlantes que des noms d’arguments.

A noter qu’il existe d’autres fonctions magiques, comme celles permettant d’acceder à des pseudos-propriétés ($u->name par exemple) de manière dynamique (avec un appel de fonction). Là aussi, jetez un oeil au manuel.

Le mécanisme de réflexion

Un autre aspect sur lequele je ne vais pas m’éterniser, le mécanisme de réflexion. Comme tous les langages de haut niveau, PHP peut s’analyser lui même, il est ainsi possible de savoir dynamiquement si une fonction existe, si une classe implémente telle ou telle interface, dans quel fichier elle est définie ou encore le noms et les valeurs des propriétés statiques.

Voila je m’arrête ici, j’éspère vous avoir donné quelques idées pour vos projets. La souplesse du langage permet de faire beaucoup de choses assez sympas qui rendent le code (celui qui utilise vos classes bizarres!) plus lisible et facile à maintenir, donc à vos claviers.