C’est quoi une interface ?

En programmation objet, une interface permet de définir les méthodes publiques qu’une classe doit implémenter. Le fait qu’une classe implémente une interface l’oblige à disposer au minimum des méthodes décrites dans cette interface au quel cas une erreur fatale sera levée.

Cela permet de définir une API (Application Programming Interface) qu’un composant pourra utiliser.

Les interfaces définies par PHP5

PHP5 propose différentes interfaces permettant de répondre à des demandes assez répandues : compter, sérialiser, traverser,  itérer, …

Pour présenter les interfaces proposées par PHP5, je baserai mes exemples sur la classe suivante :

class myObject {
  protected $_data = array( 'un', 'deux', 'trois' );
}

Cette classe implémentera au fur et à mesure de l’article les interfaces présentées.

Countable : une interface pour compter

Objectif : permettre à un objet d’être utilisé avec la fonction count() (ou sizeof())

La signature de l’interface Countable est la suivante :

interface Countable {
  public function count();
}

Noter que le système force la valeur de retour en tant qu’entier

Notre classe implémentant l’interface Countable devient :

class myObject implements Countable {
  // code précédent
  public function count() {
    return count( $this->_data );
  }
}

Utilisation :

$o = new myObject();
echo count( $o ); // Affiche 3

Serializable : linéarisation personnalisée d’un objet

Objectif : personnaliser la linéarisation/délinéarisation d’un objet.

Par défaut, lorsqu’on linéarise un objet avec serialize(), toutes les propriétés de cet objet sont traitées. On peut vouloir effectuer un traitement personnalisé lorsqu’un objet est passé à la fonction serialize() (et donc un traitement personnalisé pour serialize()). C’est ce que permet de faire l’interface Serializable dont la signature est la suivante :

interface Serializable {
  public function serialize ();
  public function unserialize ( $serialized );
}

Notre classe implémentant l’interface Serializable devient :

class myObject implements Serializable, Countable {
  // code précédent
  public function serialize() {
    return serialize( $this->_data );
  }
  public function unserialize( $serialized ) {
    $this->_data = unserialize( $serialized );
  }
}

Utilisation :

$o = new myObject();
$s = serialize( $o );// retourne C:8:"myObject":50:{a:3:{i:0;s:2:"un";i:1;s:4:"deux";i:2;s:5:"trois";}}
$o2 = unserialize( $s); // $o2 est un nouvel objet myObject

ArrayAccess : mon objet est un tableau !

objectif : accéder à mon objet comme si c’était un tableau (comme par exemple $o[0]).

la signature de l’interface ArrayAccess est la suivante :

interface ArrayAccess {
  public function offsetExists( $offset );
  public function offsetGet( $offset );
  public function offsetSet( $offset, $value );
  public function offsetUnset( $offset );
}

Notre classe implémentant l’interface ArrayAccess devient :

class myObject implements ArrayAccess, Serializable, Countable {
  // code précédent
  public function offsetExists( $offset ) {
    return isset( $this->_data[$offset] );
  }
  public function offsetGet( $offset ) {
    return isset( $this->_data[$offset] ) ? $this->_data[$offset] : null;
  }
  public function offsetSet( $offset, $value ) {
    $this->_data[$offset] = $value;
  }
  public function offsetUnset( $offset ) {
    unset( $this->_data[$offset] );
  }
}

Utilisation :

$o = new myObject();
var_dump( isset( $o[0] ) ); // true
var_dump( isset( $o['un'] ) ); // false
$o['un'] = 1;
var_dump( isset( $o['un'] ) ); // true

Iterator : itérer un objet

Objectif : personnaliser le parcours d’un objet en utilisant une boucle comme foreach()

Par défaut, lorsqu’on parcours un objet avec foreach(), on itère sur les propriétés publiques de l’objet. Dans certains cas, on préférera gérer soit même cette itération. C’est ce que permet de réaliser l’interface Iterator dont la signature est la suivante :

Iterator extends Traversable {
  public function current();
  public function key();
  public function next();
  public function rewind();
  public function valid();
}

Notre classe implémentant l’interface Iterator devient :

class myObject implements Iterator, ArrayAccess, Serializable, Countable {
  // code précédent
  public function current() {
  	return current( $this->_data );
  }
  public function key() {
  	return key($this->_data );
  }
  public function next() {
    return next( $this->_data );
  }
  public function rewind() {
  	return reset( $this->_data );
  }
  public function valid() {
  	return (bool)current( $this->_data );
  }
}

Utilisation :

$o = new myObject();
foreach( $o as $key => $value ) {
	echo "$key =>$value \n";
}
/* Affiche
 * 0=>un
 * 1=>deux
 * 3=>deux
 */

La classe MyObject terminée

La classe ainsi créée est la suivante :

class myObject implements Iterator, ArrayAccess, Serializable, Countable {
  protected $_data = array( 'un', 'deux', 'trois');
  public function count() {
    return count( $this->_data );
  }
  public function serialize() {
    return serialize( $this->_data );
  }
  public function unserialize( $serialized ) {
    $this->_data = unserialize( $serialized );
  }
  public function offsetExists ( $offset ) {
    return isset( $this->_data[$offset] );
  }
  public function offsetGet ( $offset ) {
    return isset( $this->_data[$offset] ) ? $this->_data[$offset] : null;
  }
  public function offsetSet ( $offset, $value ) {
    $this->_data[$offset] = $value;
  }
  public function offsetUnset ( $offset ) {
    unset( $this->_data[$offset] );
  }
  public function current() {
  	return current( $this->_data );
  }
  public function key() {
  	return key($this->_data );
  }
  public function next() {
    return next( $this->_data );
  }
  public function rewind() {
  	return reset( $this->_data );
  }
  public function valid() {
  	return (bool)current( $this->_data );
  }
}

Pour être mieux exploitable, la classe devrait posséder quelques méthodes supplémentaires : un constructeur acceptant un paramètre pour initialiser la propriété $_data, un getter et un setter et elle serait pleinement fonctionnelle.

Pour les plus curieux d’entre-vous, sachez que cette classe et relativement assez proche de la classe ArrayObject fournie par PHP5. Elle permet en effet d’utiliser un objet quasiment comme un tableau, ou, d’un autre point de vue, de remplacer le fonctionnement procédural des tableaux en fonctionnement objet.

Quoi qu’il en soit, cette version apporte bon nombre de nouveautés en attendant PHP 6 :

• support des espaces de nommages (namespaces);
• résolution statique à la volée (late static binding);
• fonctions anonymes et closures;
• Nowdoc;
• modification de l’opérateur ternaire : il maintenant possible d’écrire quelque chose comme expr1 ?: expr3;
• goto;
• __callStatic();
• nouvelles extensions : phar, intl, fileinfo, sqlite3, enchant;
• correction de plus de 140 bugs.

Vous pouvez retrouver l’annonce officielle de PHP ici ainsi que le changeLog ici.

PHP propose aussi un guide de migration de PHP 5.2.x ver PHP 5.3.x ici.

La page de téléchargement se trouve quant à elle ici!

Cette version corrige plus de 50 bugs sur une vingtaine de composants. Pour en savoir plus sur les nouveautés de cette version, vous pouvez vous rendre sur la page du ChangeLog.

Zend en a profité pour annoncer en même temps la mise en ligne d’une feuille de route pour les versions suivantes du Zend Framework permettant aux développeurs d’avoir une meilleur visibilité sur les nouvelles fonctionnalités qui pourraient être intégrées au Framework au cours des prochaines mise à jour.

On peut ainsi apprendre que la prochaine version majeur du Zend Framework, estampillée 1.9.0, devrait être livrée d’ici la fin juillet 2009.

Les nouveautés du modèle objet de PHP5

L’équipe de développement à voulu placer la programmation objet au sein de PHP5 proche du niveau que propose C++ ou Java. PHP nous offre donc aujourd’hui un modèle objet à simple héritage complet. Les évolutions sont nombreuses :

• auto-chargement de classe;
• ajout d’un « vrai » constructeur et d’un destructeur;
• visibilité des attributs et des méthodes;
• accès statiques aux attributs et aux méthodes;
• définition de constantes de classe;
• abstraction de classes;
• interface d’objets;
• surcharge;
• parcours d’objets;
• clonage d’objets;
• déférencement des méthodes;
• passage des objets par références par défaut.

__construct() et __destruct()

Dans sa version 4, PHP proposait déjà une méthode constructeur (méthode du même nom que la classe) qui a été redéfinie dans la version 5. Cependant, il n’y avait pas de destructeur. Ces 2 méthodes, si elles sont définies au sein de la classe, sont automatiquement appelées lors de l’instanciation de la classe et lors de la destruction de l’objet (un objet peut être détruit en utilisant delete() ou unset() et est automatiquement détruit à la fin du script).

<?php
class Bar
{
  public function __construct() {
    echo 'Je né !<br />';
  }
  public function __destruct() {
    echo 'Je meurt !';
  }
  public function doAnything() {
    echo 'Je vie !<br />';
  }
}
$obj = new Bar();
$obj->doAnything();
/**
* Affichera
* Je né !
* Je vie !
* Je meurt !
*/
?>

Visibilité

En PHP4, tous les attributs et toutes les méthodes étaient publics : ils étaient accessibles n’importe où par n’importe qui. Dans la version 5, il est possible de contrôler l’accès aux attributs et aux méthodes plus finement sur 3 niveaux :

• public : accessible à tout le monde;
• protected : uniquement accessible au sein de la classe mère ou d’une classe fille;
• private : uniquement accessible au sein de la classe mère;

<?php
/* classe mère */
class A
{
  public $var1;
  protected $var2;
  private $var3;
  public function fx1(){}
  protected function  fx2(){}
  private function fx3(){}
}
/* classe fille de A */
class B extends A
{
  public $var1;
  protected $var2;
  private $var3; // erreur
  public function fx1(){}
  protected function  fx2(){}
  private function fx3(){} // erreur
}
$objA = new A();
$objA->var1;
$objA->var2; // erreur
$objA->var3; // erreur
?>

Passage par référence et clonage d’objets

En PHP4, les objets étaient passés par valeur et non par référence. Il fallait préfixer les objets par & pour utiliser la référence. Aujourd’hui ce n’est plus le cas : PHP5 passe les objets par référence par défaut.

$src->value = 'foo';
$copy = $src;
$copy->value = 'bar';
echo $src->value; // Affiche foo en PHP4 et bar en PHP5

En utilisant le mot clé clone, on force la copie explicite de l’objet et de ses valeurs.

$src->value = 'foo';
$copy = clone $src;
$copy->value = 'bar';
echo $src->value; // Affiche foo

Déférencement

En PHP4, si une méthode renvoyait un objet, on ne pouvait pas l’utiliser directement. Il fallait obligatoirement l’enregistrer dans une variable avant de pouvoir s’en servir. PHP5 permet d’utiliser directement la valeur de retour.

// PHP4
$objB = $objA->getObjB();
$objB->doAnything();
// PHP5
$objA->getObjB()->doAnything();

C’est une fonctionnalité qui est aujourd’hui utilisée dans de nombreux frameworks PHP, notament le Zend Framework, et qui permet de chainer les actions. Le codes est ainsi allégé, plus facile à lire et c’est surtout un avantage considérable pour le développeur.

Il n’est évidemment pas possible de détailler toutes les nouveautés du modèle objet de PHP5 en un seul article. J’ai choisi celles qui me semblaient être les plus importantes, tant au niveau de l’amélioration qu’elles apportent qu’en utilité. J’aurai bien sûr l’occasion de parler des autres évolutions de PHP5 dans différents articles à venir.