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.

Les nouveautés ont déjà été évoquées dans l’article « Zend Framework 1.10beta1« .

Vous pouvez télécharger cette nouvelle version de Zend Framework sur le site officiel.

Outre l’interface utilisateur entièrement mise à jour, l’équipe de développement a intégré la puissance du module CCK dans le cœur de l’application, ainsi que la gestion poussée des images jusqu’alors « déléguée » au module ImageField.

Bien sûr, ce ne sont pas les seules nouveautés de Drupal 7.0 (qui se comptent par centaines). Les plus curieux pourront lire l’annonce officielle pour plus de détails sur cette nouvelle version.

Pour ma part, je n’ai pas encore eu le temps d’installer cette version mais je ne pourrai pas tenir bien longtemps. Soyez certain qu’un article sera rédigé dès mes premiers tests !

Et vous, avez-vous essayé cette version de Drupal 7.0 ? Quelles sont vos premières impressions ?

Demain devrait être le grand jour de la version finale de Zend Framework 1.10…

Mozilla annonce des performances améliorées d’environ 20% comparé à la dernière version de la mouture 3.5. On ne pourra pas manquer la nouvelle manière de modifier la personnalisation thèmes de Firefox : nommé « Personnas », ces skins légers permettent de changer l’interface graphique de Firefox sans avoir à redémarrer le programme.

Firefox 3.6 permet aussi une auto-complétion « intelligente » des formulaires : Firefox vous proposera des informations récupérées lors de vos précédentes saisies pour des champs semblables.

Coté développeurs, le HTML5 est pris en compte dans ses dernières spécifications. Les polices embarquées WOFF (Web Open Font Format) sont prises en charge, ainsi que les fonds multiples, les dégradés CSS, la détection de l’orientation de l’écran, … Vous pouvez retrouver toutes les nouveautés pour les développeurs ici.

L’annonce officielle en français se trouve ici.

Avez-vous franchis le pas et déjà mis à jour votre version de Firefox ? Que pensez-vous de ces nouveautés ?

les développeurs vont pouvoir tester les nouveaux composants parmi :

• Zend_Barcode;
• Zend_Cache_Backend_Static;
• Zend_Cache_Manager;
• Zend_Exception;
• Zend_Feed_Pubsubhubbub;
• Zend_Feed_Writer;
• Zend_Filter_Boolean;
• Zend_Filter_Compress/Decompress;
• Zend_Filter_Null;
• Zend_Log::factory();
• Zend_Log_Writer_ZendMonitor;
• Zend_Markup;
• Zend_Oauth;
• Zend_Serializer;
• Zend_Service_DeveloperGarden;
• Zend_Service_LiveDocx;
• Zend_Service_WindowsAzure;
• Zend_Validate_Barcode;
• Zend_Validate_Callback;
• Zend_Validate_CreditCard;
• Zend_Validate_PostCode.

ainsi que de nombreuses améliorations.

De plus, Zend annonce une sortie de la version finale de Zend Framework 1.10 pour le 26 janvier prochain.

Retrouver l’annonce officielle de la sortie de Zend Framework 1.10beta1.

La librairie passe désormais en version 1.4 apportant son lot de nouveautés.

Vous pouvez retrouver l’annonce officielle sur le blog de Jquery, ainsi que les nouveautés sur la page de la documentation.

Pour télécharger la nouvelle version de Jquery ça se passe ici.

Voilà qui devrait – normalement – faciliter la vie des webmasters gérant de nombreux sites.

Cependant, je trouve dommage que Google affiche le favicon présent à la racine du site (domaine.tld/favicon.ico) et non celui fourni dans l’en-tête de la page web, ce qui posera des problèmes avec les scripts permettant de gérer plusieurs sites (comme Wordpress Mµ, Drupal ou encore Magento).

N’ayant ni le temps ni l’envie de savoir si j’étais réellement en faute, j’ai décidé de répondre favorablement à leur requête.

C’est pour cette raison que webdev-memento.fr devient à partir de maintenant web-memento.fr.

Les URLs des auteurs de commentaires n’étaient pas correctement nettoyées lors de l’affichage dans le panneau d’administration. Cela pourrait être utilisé pour rediriger du panneau d’administration vers un autre site.

La nouvelle version de Wordpress 2.8.2 peut être téléchargée ici, ou via l’outil de mise à jour inclu dans Wordpress.

Retrouver l’annonce officielle ici.