Du lien frais (ou pas)

Quelques liens sympas concernant le développement Web :

• Blackbird – alert(), c’est dépassé, la console de Firebug, c’est bien ; mais il y a mieux ! Blackbird est une console très sympa de logging Javascript qui s’active / désactive avec clavier, se déplace, etc… ;
• Une idée sympa de système de login avec un panneau qui slide ;
• Un générateur de règles CSS3 ;
• Une collection de scripts LUA pour Lighttpd pour tout type de problèmes, de quoi rendre Lighty le rapide aussi complet que le gros apache bien lent ;
• Un plugin jQuery pour faire des <input> avec des masques de format.

Bonne lecture !

Abracadabra...

Les objets en PHP possèdent 14 méthodes « magiques », reconnaissables à leurs noms qui commencent par deux underscores « __ » : __construct, __destruct, __call, __callStatic, __get, __set, __isset, __unset, __sleep, __wakeup, __toString, __invoke, __set_state, __clone.

Une méthode « magique » en PHP, c’est une méthode dont le nom est réservé (vous ne pouvez pas utiliser ces noms pour appeler vos propres méthodes, d’une manière générale, ne nommez jamais une méthode avec un nom qui commence par « __ »), que le moteur PHP va tenter d’appeler dans lors de certains évènements propres à votre classe si celles-ci existe.

Par exemple, si vous avez une méthode appelée « __construct » dans votre classe, celle-ci sera appelée lorsque l’on instancie une instance de votre classe : new MaClasse().

Dans la plupart des cas (sauf si précisé), ces méthodes doivent être définie comme publique et non statiques (ex : public function __construct()).

Voyons-les en détails …

__construct

La plus connue d’entre elles ; beaucoup l’utilisent sans savoir qu’il s’agit d’une méthode « magique ». __construct est ce qui s’apparente à un constructeur en C++, c’est-à-dire qu’elle est appelée à chaque instanciation de votre objet. Par exemple, si j’appelle new MaClasse("test", 5 ) ;, la méthode __construct de MaClasse va être appelée avec comme argument "test" et 5. Il est inutile de retourner une valeur dans cette méthode, ce retour serait ignoré.

Par convention, on place dans la méthode __construct toutes les initialisations nécessaires à l’utilisation d’un objet, comme par exemple la connexion à une base de données, les valeurs par défaut des variables, etc.

A noter qu’en cas d’instanciation d’une classe fille (qui hérite de la classe), __construct ne sera pas appelé, si la classe fille (ou une des classe dans l’héritage) implémente une fonction __construct ; il faudra alors appeler parent::__construct(…) dans la méthode __construct de cette classe fille.

__destruct

__destruct est appelé lorsque qu’une instance de notre classe est détruite (elle n’est plus utilisée, ou la fin du script est arrivée par exemple), elle n’a aucun argument.

A l’inverse de __construct, on place dans cette méthode tout ce qui est nécessaire à la fin de vie de notre objet, comme par exemple la déconnexion d’une socket, la libération de mémoire cache, etc.

Attention, l’utilisation de cette méthode est souvent très sensible :

• Souvent, celle-ci est appelée en fin de script, c’est-à-dire à un moment ou les en-têtes (headers) sont déjà envoyés ;
• Si une exception est levée pendant l’exécution de cette méthode, une erreur fatale PHP est levée et le reste (de la fin) du script ne sera pas exécuté ;
• Beaucoup de ressources (instances d’autres classes, connexion à des bases de données) dont probablement déjà plus disponibles.

__call

__call est appelé lorsque l’on essaye d’appeler une méthode qui n’existe pas dans la classe. Par exemple, si j’essayer d’appeler $objet->fooBar("test", 5) ; que fooBar n’est pas une méthode définie dans ma classe et que j’ai une méthode __call définie, celle-ci va être appelée avec comme arguments "fooBar" (le nom de la méthode appelée) et un tableau contenant "test" et 5 (les arguments).

__callStatic

__callStatic fait la même chose que __call, mais est appelée lorsque l’on essaye d’appeler une méthode statique qui n’existe pas ; par exemple MaClasse::fooBar("test", 5) ; appellera __callStatic avec comme arguments "fooBar" (le nom de la méthode appelée) et un tableau contenant "test" et 5 (les arguments).

Attention, comme callStatic est appelé dans un contexte statique, il faut définir la méthode de manière publique et statique (public static function __callStatic($name, $args) { ).

__set

__set est appelé lorsque l’on essaye de définir une propriété qui n’existe pas.

Par exemple $object->fooBar = 5; appellera __set avec comme arguments "fooBar" (le nom de la propriété) et un 5 (la nouvelle valeur). Cependant, cette propriété ne sera pas créée pour autant !

A noter que __set est appelée lorsque l’on essaye de modifier la valeur d’une propriété privée ou protégée depuis l’extérieur de la classe.

__get

__get est appelé lorsque l’on essaye de récupérer la valeur d’une propriété qui n’existe pas.

Par exemple echo $object->fooBar; appellera __get avec comme argument "fooBar". La valeur alors retournée par la méthode __get sera retournée à l’appel (echo dans l’exemple).

A noter que __get est appelée lorsque l’on essaye de récupérer la valeur d’une propriété privée ou protégée depuis l’extérieur de la classe.

__isset

__isset est appelé lorsque l’on essaye de savoir si une propriété qui n’existe pas est définie, avec isset() par exemple.

Par exemple isset($object->fooBar) appellera __isset avec comme argument "fooBar". La valeur alors retournée par la méthode __get sera retournée à l’appel, celle-ci doit donc de préférence retourner true ou false.

A noter que __isset est appelée lorsque l’on essaye de savoir si la valeur d’une propriété privée ou protégée est définie depuis l’extérieur de la classe.

__unset

__unset fait à peu près la même chose que __isset, donc vous avez tout deviné … J

__sleep et __wakeup

Ces anciennes méthodes permettent de linéariser et délinéariser des objets d’une classe. La linéarisation permet à un objet d’être enregistré (comme par exemple dans une base de données ou une mémoire cache) dans un état défini (comprendre les valeurs des méthodes par exemple). Ceci peut être très utile par exemple si l’on veut enregistrer un objet de session.

Par défaut, les objets linéarisés le sont à l’aide de la fonction serialize() de PHP, mais cela peut s’avérer insuffisant, comme par exemple si l’on doit avant se déconnecter d’une base de données ou faire du nettoyage.

Deux méthodes magiques existent pour cela, __sleep et __wakeup, mais il est fortement déconseillé de les utiliser car il est impossible alors d’accéder au nom des propriétés privées ou protégées des classes parentes, il faut alors utiliser l’interface Serializable. Ce n’est pas une méthode magique, mais elle les « remplace », je vais donc en parler ici.

Serializable définit deux méthodes : serialize et unserialize :

• serialize() est appelé lorsque l’on appelle la fonction PHP serialize($objet) ;. Elle doit alors retourner une chaîne qui pourra être récupérée pour réinitialiser l’objet dans l’état actuel ;
• unserialize($string) est appelé lorsque l’on appelle la fonction PHP $object = unserialize($string) ;. Elle doit alors récupérer la chaîne $string pour réinitialiser l’objet dans l’état décrit par celle-ci. Dans ce cas, $object sera alors une instance de la classe réinitialisé, mais __construct() ne sera pas appelé. Elle doit modifier l’objet mais ne rien retourner (comme __construct).

Voici un exemple de classe pour être plus clair :

/**
 * Classe mere
 */
class          Compteur {
  /**
   * Somme
   *
   * @var  int
   */
  protected      $_sum;
}
/**
 * Une classe tout bête qui compte le nombre de fois
 * qu'on l'a appelée et fait une somme
 */
class          CompteurBete extends Compteur implements Serializable {
  /**
   * Nombre de fois qu'on l'a appellé
   *
   * @var  int
   */
  private        $_calls;  

  /**
   * Constructeur
   */
  public function    __construct() {
    $this->_sum = 0;
    $this->_calls = 0;
    echo "Constructeur appellé !\n";
  }
  /**
   * On ajoute un nombre a la somme
   *
   * @param  int      Nombre
   */
  public function      add($number) {
    $this->_sum += intval($number);
    $this->_calls++;
  }
  /**
   * Quelle est la somme ?
   *
   * @return  int
   */
  public function      getSum() {
    return($this->_sum);
  }
  /**
   * Combien de fois ai-je été appelé
   *
   * @return  int
   */
  public function      getCalls() {
    return($this->_calls);
  }
  /**
   * La méthode qui fait la sérialisation
   *
   * @return  string    Chaîne qui représente l'état de l'objet
   */
  public function      serialize() {
    return("{$this->_sum}|{$this->_calls}");
  }
  /**
   * La méthode qui réinitialise l'objet dans l'état sérialisé
   *
   * @param  string    Chaîne retournée par serialize()
   */
  public function      unserialize($serialized) {
    if (preg_match("/^([\-\d]+)\|([\-\d]+)$/", $serialized, $parts)) {
      $this->_sum = intval($parts[1]);
      $this->_calls = intval($parts[2]);
    } else {
      throw new Exception("La chaîne ne représente pas une instance de CompteurBete : " . $serialized);
    }
  }
}

Si on exécute le code suivant :

/**
 * On cree notre objet
 */
$object = new CompteurBete();
/**
 * On joue avec
 */
$object->add(5);
$object->add(10);
$object->add(-25);
/**
 * On le serialize
 */
$serialized = serialize($object);

echo "Nombre d'appels : " . $object->getCalls() . "\n";
echo "Somme : " . $object->getSum() . "\n";
echo "Chaîne sérialisée : " . $serialized . "\n";

On obtient le résultat :

Constructeur appellé !
Nombre d'appels : 3
Somme : -10
Chaîne sérialisée : C:12:"CompteurBete":5:{-10|3}

La chaîne « C:12: »CompteurBete »:5:{-10|3} » peut être traduite par « Une instance de la classe « CompteurBete » que l’on peut désérialiser avec la chaîne « {-10|3} » ».

Donc si l’on exécute maintenant le code :

/**
 * On passe la chaîne récupérée
 */
$newObject = unserialize('C:12:"CompteurBete":5:{-10|3}');
echo "Nombre d'appels : " . $object->getCalls() . "\n";
echo "Somme : " . $object->getSum() . "\n";

On obtient :

Nombre d'appels : 3
Somme : -10
Magnifique ! Le même résultat ! Notre objet est donc bien réinitialisé !

Vous noterez que j’ai « implémenté » un système maison de sérialisation/désérialisation maison mais il est souvent préférable de se baser sur des systèmes tels que serialize()/unserialize() de PHP…

__toString

__toString est appelé lorsque l’on essaye d’utiliser une classe comme une chaîne de caractères, par exemple lorsque l’on appelle echo $object ;.La méthode __toString est alors appelée, sans argument, et doit retourner une chaîne qui sera à son tour retournée à l’appelant.

C’est très utile lorsque l’on crée des classes qui représentent des balises HTML, on peut alors travailler avec ces classes avec des appels du type :

$tag = new HTMLTag('ul');
$tag->setClass('maClasse')->setId('monId')->html('Hello');
echo $tag;  // Va afficher

__invoke

__invoke est appelé lorsque l’on essaye d’appeler un objet comme une fonction. Par exemple, si l’on effectue $object(« buuum ») ;, la méthode __invoke va être appelée avec comme argument « buuum ».

Cela peut être utile notamment lorsque l’on souhaite utiliser une fonction de PHP qui utilise une fonction comme argument, comme usort(), à laquelle on peut passer comme argument l’objet.

A noter, pour tester si une instance d’une classe implémente __invoke, on peut utiliser is_callable().

__set_state

__set_state est un peu complexe à définir, et à mon avis pas très utile, mais essayons quand même. Pour comprendre __set_state, il faut d’abord connaitre la fonction PHP var_export().var_export() c’est le même principe que var_dump(), c’est-à-dire afficher des informations sur une variable, mais avec deux différences :

• · var_export peut retourner les infos plutôt que de les afficher si on précise true en deuxième argument ;
• · var_export retourne du code PHP valide.

Si l’on prend le code suivant par exemple :

$number = 5;
$string = "ouech";
$array = array(1, "t'as vu", false);
class test {
  public        $property = 5;
  private        $_property = "ok";
  public function    method() { /**/ }
}
$object = new test();
echo var_export($number) . "\n";
echo var_export($string) . "\n";
echo var_export($array) . "\n";
echo var_export($object) . "\n";

On obtient le résultat suivant :

5
'ouech'
array (
  0 => 1,
  1 => 't\'as vu',
  2 => false,
)
test::__set_state(array(
  'property' => 5,
  '_property' => 'ok',
))

Penchons-nous donc sur le dernier résultat, concernant l’objet. var_export() retourne un code qui est un appel à une méthode __set_state sur la classe test. On y est dont, à cette méthode.

En fait, cette méthode prend en argument un tableau qui représente la liste des propriétés de l’instance de la classe. La méthode doit normalement récupérer créer une instance de la classe, assigner les propriétés récupérées et retourner cet objet, afin de pouvoir faire quelque chose comme eval(‘$newInstance =’ . var_export($oldInstance, true) . ‘;’) ;

Donc :

• · La méthode __set_state est une méthode publique statique, on a donc pas accès aux propriétés protégées et publique de l’objet qu’on doit réinitialiser, il faut donc faire des méthodes « setter » ;
• · C’est ignoble, immonde et lent comme code (et oui eval()…) ;
• · C’est pas très sécurisé, voire pas du tout (et oui eval()…) ;
• · La méthode peut en fait faire n’importe quoi et retourner n’importe quoi…

Si quelqu’un à compris quelle est l’utilité de __set_state, donc, qu’il se manifeste !

__clone

__clone est appelé lorsque l’on souhaite cloner une instance de la classe avec la fonction PHP clone(). En effet, on peut dans certains cas vouloir contrôler le clonage d’une instance de notre classe pour par exemple partager des ressources (base de données, etc.), voir l’empecher.

Lorsque l’on appelle clone() sur un objet et que la méthode __clone est implémentée, celle-ci sera invoquée alors sur le nouvel objet cloné juste après sa création.

Classe !

Pouvoir faire de la complétion dans un <textarea>, c’est possible, avec tx-content-assist, c’est possible !

C’est en fait une réécriture du moteur d’assistance de code de Eclipse, et c’est même possible de le déclencher avec « Ctrl+Espace » / « Alt + Espace » (enfin, certains navigateurs l’ont déjà reservé).

Pour une petite démo, c’est par ici, pour les sources, c’est sur github.

Une fois n’est pas coutume, je n’avait plus mis à jour ce blog depuis longtemps.

Me revoilà, donc, avec un nouveau design !

Pas de flash, pas de chocolat

Futurs possesseurs de l’iPad, farouches combattant du Flash, vous voulez vous aussi pouvoir utiliser un outil de dessin On Line ?

Alors voici SketchPad, une application de dessin proche de Photoshop Express et des autres outils d’online painting, mais avec un particularité : Il est développé en HTML5/Javascript. Tout est donc contrôlé via des Canvas, vous n’avez donc pas besoin d’avoir Flash sur votre machine (mais un navigateur compatible HTML5 qui supporte les Canvas).

Have fun !

Une super idée !

Comment innover dans un milieu aussi rôdé que celui des sites Internet d’agence ? Avec un vidéo Youtube !

Oui mais pas n’importe quelle vidéo, une vidéo interactive monté comme un site, rondement bien ficelée, autant niveau technique que niveau production.

Cependant, même si l’idée est excellente et bien exécutée, il semblerait qu’ils n’utilisent QUE cette vidéo comme site, et là c’est très dangereux. Quid des clients qui ont Youtube bloqué sur leur proxy d’entreprise ? Ou du référencement ? Et si Youtube supprime la vidéo ?

Quoi qu’il en soit le buzz est parti, et la vidéo, c’est ici :

http://www.youtube.com/watch?v=Elo7WeIydh8

(Merci à Olivier pour l’info !)

Il les surpasse tous !

Après 3 ans d’une histoire d’amour fidèle avec Memcached ; le serveur de cache notamment utilisé par Facebook, Youtube ou Twitter ; je suis au bord de la rupture après avoir rencontré redis.

redis, A persistent key-value database

Oui, database. En fait, redis, c’est les avantage d’un système de cache sans les inconvénients.

D’habitude avec les systèmes de caches comme Memcached, les données mises en cache sont volatiles. Elles sont stockées en mémoire pendant un certain temps ; passé ce délais elles sont supprimées.

Ce point n’est pas bloquant, une données mise en cache doit pouvoir être recalculée ou récupérée à tout moment, mais cela consomme des ressources en plus (pour récupérer cette donnée, justement).

redis est conçu sur un autre modèle. Les données sont dans un premier temps stockées en mémoire de la même manière que les autres, mais elles sont de manière cycliques (tout les X écritures ou après X temps) écrites sur le disque dur. On peut donc stocker une donnée de manière permanente !

A noter cependant que Memcache existe en version persistante (MemcachedDB), cependant on il ne fait QUE du stockage persistant, on perd donc en performance.

Des performances impressionnantes

Afin de comparer les performances de Memcached, réputé et reconnu pour sa rapidité, et celles de redis, j’ai fait un simple test pour Memcache :

Et pour redis :

Résultat : Avec redis on est en moyenne à 2,507 secondes pour 10 000 itérations, pour Memcached on est à 3,669 secondes.

redis est donc plus rapides que Memcached sur des opérations de bases (écriture, lecture) il fallait le faire !

Sinon pour être un peu plus complet, une page de benchmark est présente sur le site.

Au delà du stockage « clé-chaîne »

Un autre inconvénient de Memcached ou d’autres système de cache, c’est qu’il fonctionne sur un modèle « clé-chaîne de caractère« , il ne peut donc stocker que des combinaisons du type (‘clé de cache’, ‘valeur à stocker’).

Lorsque l’on doit enregistrer des données plus complexes comme des tableaux, on est alors obligé de passer par une mécanique de sérialisation des données ou Mashalling, comme serialize() en PHP.

redis permet en plus du mode de stockage « clé-chaîne » un mode de stockage « clé-liste » qui permet de stocker des listes. Il est donc possible, au delà de stocker et récupérer des valeurs, d’utiliser les fonctions classiques de listes, comme changer une valeur dans cette liste, récupérer une valeur ou un ensemble de valeur dans la liste, la modifier etc. et ce sans avoir à récupérer la liste, la modifier et la renvoyer comme c’est le cas avec les autres systèmes.

Ceci est un gain énorme de ressources système et de temps tout en simplifiant la gestion du cache !

Multiple bases de donnée

Un même serveur de cache peut être utilisé par plusieurs systèmes de cache. Souvent cela est problématique car les données ne sont pas séparées par application. On utilise alors souvent un système de préfixage des clés, par exemple la clé ‘UsersCount’ sera nommée ‘MyApplication_UsersCount’ pour éviter d’écraser une clé d’une autre application.

redis offre une gestion par « base de donnée » comme le font les base de données classiques ; ce qui permet entre autre de vider le cache d’une application sans effacer les autres données ou de lister rapidement les données en cache d’une application donnée.

Implémentation langages

Pour utiliser redis il existe des libraries ou classe en Ruby, Python, PHP, Perl, Java, etc. ; la liste est présente sur le site du projet.

IE6 ? No more !

Après avoir hésité quelque temps, Microsoft à craqué face au lobby des D.S.I. aussi vieillissant que leur navigateur préféré : Le support d’Internet Explorer 6 sera maintenu jusqu’en 2014.

Amy Barzdukas, la directrice de l’activité IE chez Microsoft, à même des arguments chocs :

Il est difficile d’être cavalier avec cette économie en disant « oh il est temps de se mettre à jour »

Mais elle est consciente quand même que :

Si les gens qui sont frustrés par cette expérience commencent à dire « Microsoft craint et IE craint » en se basant sur une technologie vieille de bientôt 10 ans alors cela devient effectivement préoccupant

Si l’on résume donc :  Microsoft, pour ne pas froisser quelques D.S.I. à décidé de maintenir IE6, et donc, par la même légitimer un choix suicidaire de continuer à exploiter et même développer des intranets et applications Web pour Internet Explorer 6, quitte à s’exposer à une perte de crédibilité et une baisse d’image auprès « des gens ».

Je ne reviendrais pas sur les raisons qui font que IE6 doit immédiatement mourir de sa belle mort après presque 10 ans d’activité… Je constate juste qu’il est dommage de voir que Microsoft, qui semblait petit à petit adopter une stratégie plus réfléchie à propos des navigateurs (plus d’efforts pour adopter des standards, ballot screen, etc.) revient donc à ses origines.

Adoptez une ligne de code de Miro !

Les projets Open Source et gratuits ont souvent du mal à se financer, et souvent en arrivent au même point : la cyber-quête !

Le player Open Source Miro n’échappe pas à la règle mais propose une méthode assez originale : il vous est proposé d’adopter une ligne de code du player. Sympa non ?

J’ai personnellement adopté January

Aptana Studio

Un I.D.E. pour un développeur, c’est l’une des choses primordiales. C’est une façon de travailler, des habitudes de développement et souvent, c’est presque une impératif. Bien sur, certains diront qu’un vrai développeur peut travailler avec n’importe lequel et c’est souvent vrai, mais avouons-le, nous avons tous nos petites habitudes !

Depuis quelques années, je travaillais avec Zend Studio, que j’avais adopté plus par contrainte de mon employeur au début, mais depuis l’évolution de celui-ci vers Eclipse, j’avais lâché le train en route n’ayant le temps de m’y mettre et je suis resté cloitré sur l’ancienne version (5.2), que certes je maitrisais jusqu’au bout des menus, mais commençait sérieusement à vieillir.

J’ai donc décidé d’essayer Aptana Studio, dont on me parlait en bien depuis quelque temps et qui sur le papier, me séduisait fortement.

Après 1 mois, voici mes retours d’expérience.

Ce que j’ai aimé :

Le support de jQuery

Aptana est livré avec le support prépackagé de plusieurs librairies / frameworks Javascripts, dont jQuery.

A la clé, des templates de codes, de la complétion, de la coloration syntaxique adaptée, et caetera.

Le support de Smarty

Je suis depuis plusieurs années, un gran fan de Smarty (non pas les bonbons, quoique), que je continues à utiliser comme Vue dans mes développements MVC sur Zend Framework.

Et la, encore une exclusivité, Aptana Studio nous offre un complétion de code, un coloration syntaxique et tout le toutim pour les fichiers de gabarits smarty, y compris sur vos propres fonctions !

En bref, les complétions multilangage

En plus des deux éléments cités, Aptana Studio offre une complétion très bien faite sur tout ce qui est possible : HTML, PHP, XML, JSON, CSS, etc. Et ca marche plutôt bien !

Ce que je n’ai pas aimé :

Des bugs en pagaille dans le formatage

Au fur et à mesure que je configurais des fonctionnalités, j’ai eu de plus en plus de fil à retordre avec des bugs, plus ou moins génants.

Le plus embêtants se trouvent au niveau du formatage de code. Aptana Studio, comme la plupart des I.D.E. basés sur Eclipse vous propose de formater votre code selon les règles que vous avez configurées, comme les retour à la ligne, les indentations, les espaces après les virgules, etc.

Force est de constater que par exemple, les retours à la ligne dans la déclarations de tableaux (array()) ou ceux des déclarations CSS qui commencent par un identifiant (#monDiv .maClasse) ont des comportements complètement aléatoire !

Des bugs aussi dans la gestion « remote »

Eclipse (ce n’est qu’un point de vue…) n’est pas pratique pour développer ‘en remote’ ; c’est à dire que vous modifiez et testez sur un serveur distant via FTP ou SFTP par exemple.

Un bout de scotch est malgré tout là pour parer à cette problématique dans Aptana c’est un petit script bien nommé « Upload file on save » qui est censé envoyer vos fichiers via FTP / SFTP lorsque vous les sauvegarder.

Première mauvaise impression : il faut modifier le script pour l’activer !

Deuxième : il ne marche pas une fois sur trois, et tout est désynchronisé.

Des fonctionnalités mal finies

J’ai été impressionné lorsque j’ai vu un onglet « iPhone view ». Pensez donc ! Un émulateur iPhone intégré à un I.D.E !

En fait, il ne s’agit que d’une preview HTML de votre navigateur classique rétrécie au dimensions du mobile et entourée d’une photo d’iPhone … arf !

Une complétion PHP de votre projet mal pensée

Si vous souhaitez avoir une complétion sur vos propre classes (évidemment !) en PHP. Beaucoup de manipulations nécessaires : il va falloir définir la nature primaire de votre projet en PHP et ajoutez les répertoires ou sont vos classes dans une liste. Et ce pour chaque projet.

Bien sur, il va falloir après à la main les supprimer, sinon vous atteindrez les 45 secondes à l’ouverture de chaque projet des les 5 projets (~ 1 Mo de code) atteint …

Conclusion

Malgré une première impression, Aptana Studio semble très utile, très prometteur, mais pas assez stable et mature pour que je l’adopte. Dommage.

Je vais maintenant me pencher sérieusement sur Zend Studio 7 (qui gère PHP5.3 !)… Retours dans quelques semaine, sauf incident majeur

T'étais ouuuuuu ?

Une fois de plus, je vous ai abandonné pendant presque un mois.

Désolé, j’étais invité par David et Cathy Guetta pour la soirée F**k Me I’m Famous de Meudon. On a pris des acides et bu du cidre, du coup on a pas vu le temps passer.

Bref, beaucoup de travail, tout ça, tout ça.

Les nouveautés de PHP5.3

Le 30 Juin dernier est sorti PHP5.3, discrètement… Pourtant c’est une évolution majeure, qui ne comprends pas que des corrections de bugs (140 corrections quand même).

Quoi de neuf alors dans cette version ?

Les namespaces

Annoncé comme l’une des évolutions majeures du légendaire PHP6 (sortie en 2087, peut être), les namespaces ou espaces de nommages sont l’une des dernières étapes de la route vers un vrai langage objet.

Alors qu’est ce que c’est « simplement » ? C’est un moyen de faire cohabiter ensemble plusieurs librairies de manière simple et d’organiser simplement son code.

Le but premier est de pouvoir nommer simplement des classes, constantes et fonctions sans risquer le conflit avec du code existant. Jusqu’ici, on utilisait des techniques, comme par exemple nommer ses classes en respectant des règles comme  NomDuFramework_NomDeLaLibrairie_NomDeLaClasse. Avec les namespaces, il est simple de compartimenter son code et ne pas se soucier des conflits.

Un exemple, qui j’espère, sera parlant :

/**
 * On execute du code dans le deuxièmme espace
 */
namespace        Espace2 {
  echo "On est dans le deuxièmme espace :\n";
  var_dump(CONSTANTE);
  fonction();
  $objet = new Classe();
  $objet->test();
  echo "\n\n";
}
/**
 * On execute du code dans l'espace global
 */
namespace {
  echo "On est dans l'espace global :\n";
  echo "Est-ce que la constante CONSTANTE est définie ?\n";
  var_dump(defined('CONSTANTE'));
  echo "Est-ce que la fonction fonction() est définie ?\n";
  var_dump(function_exists('fonction'));
  echo "Est-ce que la classe 'Classe' est définie ?\n";
  var_dump(class_exists('Classe'));
}
?>

Avec cette évolution, on fait un pas de plus vers les lettres de noblesse de PHP dans le monde des langages objets, à plus d’un point.

Aujourd’hui, beaucoup de gens pensent leur code comme une accumulation de fonctions (souvent un copier-coller de sites). Utiliser des namespaces pousse le développeur à s’imposer une certaine rigueur et à bien séparer son code de manière logique.

J’attends avec impatience la 2.0 de Zend Framework qui utilisera les namespaces

Les fonctions anonymes

Les fonctions anonymes (ou closures) sont des blocs de codes exécutables (donc des fonctions) mais qui ne possèdent pas de noms pour être rappelées plus tard. La première fois cela peut paraitre déroutant et on peut ne pas comprendre l’utilité, mais par exemple, si vous utilisez jQuery, vous saisissez immédiatement l’opportunité !

Prenons par exemple la fonction PHP array_walk() qui permet d’appliquer une fonction sur chaque élément d’un tableau. Avant on définissait une fonction, on la nommait et on passait le nom de la fonction en argument, comme ceci :

function cmp($a, $b) {
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}
uasort($array, 'cmp');

Maintenant, on peut directement passer une fonction anonyme comme argument sans avoir à créer de fonction au préalable :

uasort($array, function($a, $b) {
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
});

"late static binding"

Le late static binding ou la "Résolution statique à la volée" est un concept assez théorique au premier abord mais qui solutionne une importante limitations de PHP.

Dans le cadre de méthodes statiques d'une classe, le mot clé self ou la constante __CLASS__ qui font référence à la classe "courante" sont assignées par PHP lors de l'analyse du code et non au moment de l'exécution, donc en cas d'héritage, elles font référence à la classe parente et non à la classe courante.

Cela peut paraitre compliqué, alors prenons un exemple, le code suivant :

affichera "Je suis la classe Papa".

PHP5.3 étend donc le mot-clé static, pour l'utiliser comme une référence à la classe courante pendant l'exécution et non pendant la compilation. On peut donc écrire le code suivant :

class    Papa {
  public static function  jeSuis() {
    return (__CLASS__);
  }

  public static function  annonceToi() {
    echo 'Je suis la classe ' . static::jeSuis() . "\n";
  }
}
class    Filston extends Papa {
  public static function  jeSuis() {
    return (__CLASS__);
  }
}

Filston::annonceToi();

qui affichera bien "Je suis la classe Filston".

Le contrôle du garbage collector

Pour ceux qui ne serait pas à l'aise, consultez l'article Garbage Collector sur Wikipedia.

N'ayant eu le temps de tester encore en détail, je vous conseille la lecture de ce très bon billet.

L'opérateur ternaire simplifié

$valeur = ($valeur) ?: $default;

à la place de

$valeur = ($valeur) ? $valeur : $default;

Et puis aussi ...

D'autres petits changements que je vous laisse consulter...

Bonne lecture et bon tests !