Ilia Alshanetsky a annoncé aujourd’hui la sortie de la dernière release mineur de PHP, numérotée 5.3.7. Cette version mineure est la première à avoir suivi la RFC sur le processus de gestion des releases de PHP. Je parlais dans un article précédent de la volonté de professionnalisation des développeurs de PHP. Cette réussite marque donc la fin d’une gestion quelque peu chaotique, tout du moins trop peu organisée.

Les extensions SQLite et PCRE ont été mises à jour respectivement aux versions 3.7.7.1 et 8.12. PHP 5.3.7 corrige également plus de 90 bugs dont une demi douzaine concernait des problèmes de sécurité.

L’annonce officielle a également marqué la fin du support de PHP 5.2.

PHP fait partie des principaux langages de programmation utilisé dans le monde, il reste très populaire. Créé en 1994 par Rasmus Lerdorf (aussi appelé Dieu dans le milieu), PHP a énormément évolué, près de 31 version mineures pour 5 versions majeures dont la dernière, la 5.0.0, est sortie est en 2004. L’année 2004 peut sembler lointaine pour la dernière sortie d’une version majeure. En réalité les versions mineures 5.1.0, 5.2.0 et 5.3.0 ont amené de très nombreuses modifications même si elles n’ont pas été baptisées « version majeure ». Pour plus d’informations, vous pouvez consulter l’historique au lien suivant.

Contrairement à ses principaux concurrents (.Net ou Java), ce langage n’est pas géré par une entreprise. Ce sont des développeurs (appelés contributeurs) qui bénévolement créent, maintiennent et font évoluer ce langage. De profonds désaccords au sein de la communauté ont eu raison de la version 6 de PHP qui était annoncée comme le messie. Le projet a été abandonné depuis plus d’un an déjà. Pour autant tout n’a pas été perdu. En effet la plupart des avancées programmées dans cette version 6 ont été récupérées et intégrées dans les versions mineures de PHP 5.3. Cet échec, on peut le nommer ainsi, a montré les limites de l’évolution de PHP.

Pour pallier à tous ces problèmes structurels, la communauté s’est accordé sur des méthodes, des outils. Clarté et transparence sont désormais de mise. Toute évolution doit passer par une RFC. Les contributeurs ont d’ailleurs réussi à se mettre d’accord sur les deux RFC suivantes :

• Un processus de release. Cette RFC permet de donner des jalons à la création des nouvelles versions, ce qui n’existait pas auparavant. Celle-ci met aussi un terme à la sacrosainte compatibilité qui existait jusque là. La compatibilité va enfin pouvoir être cassée quand cela s’avèrera nécessaire.
• Un processus de vote. Le but de cette RFC est de définir une méthode de vote. Par le passé, il était parfois difficile de connaître les dates de début ou de fin de vote.

Pour ceux que cela intéresse, vous pouvez obtenir plus d’explications au lien suivant. L’article détail les choix à faire concernant des fonctionnalités potentielles.

PHP est souvent considéré comme non professionnel, les stéréotypes sont difficiles à perdre. D’ailleurs la plupart des personnes ayant ces arguments connaissent PHP avec une si ce n’est deux versions de retard. Les contributeurs esssaient au fur et à mesure des nouvelles versions de mettre en place ce qui est reproché à PHP. On ne peut donc qu’apprécier la volonté de supprimer certains « boulets historiques » du langage (ex: les magic quotes).
Le typage des variables revient souvent comme argument. Ainsi la prochaine version devrait transformer les types primitifs (int, bool…) en mots réservés, ce qui permettra d’imposer le type des arguments passés dans des fonctions.

En accord avec le calendrier, la version alpha 2 est disponible au téléchargement depuis hier. Espérons que la prochaine version sortira également à la date convenue… En tout cas, j’ai pour ma part hâte de pouvoir travailler avec cette version.

PHP a annoncé il y a quelques jours la sortie de la version 5.3.4. Cette version est une évolution de maintenance de la série 5.3. Il n’y a donc pas d’évolution majeure, uniquement des correctifs de bugs.

Cela fait un petit moment que cela a été annoncé, mais je le précise pour les lecteurs de ce blog (qui s’y intéressent). La version 6 de PHP telle qu’elle était prévue depuis plusieurs années a été officiellement abandonnée. Les très nombreuses dissensions entre les équipes de développement ont en effet abouti à la mort de PHP 6 dans cette version. Tout n’est pas perdu puisque certaines évolutions ou corrections de PHP 6 sont de toute façon été intégrées dans les releases mineurs de PHP 5.3. Les désaccords sont principalement axés autour de deux points :

• la volonté de professionnalisation de PHP d’une branche de développeurs
• la volonté de garder une compatibilité descendante

Les débats sont aujourd’hui repartis sur des bases plus saines.

La dernière version stable de PHP est disponible depuis hier. Quatre mois après la sortie de PHP 5.3.2, la version 5.3.3 corrigent près d’une centaine de bugs, dont certains posaient des problèmes de sécurité.

Au-delà des corrections de bugs, cette nouvelle release entraîne un incompatibilité concernant la déclaration des constructeurs des classes appartenant à un espace de nom. Les « namespaces » ou espaces de nom n’ayant été introduit dans PHP que dernièrement dans le version 5.3, l’incompatibilité ne pose donc problème que pour les versions 5.3.x.

Depuis l’apparition de la POO dans PHP, les concepts ont bien évolués, l’écriture et l’interprétation du code également. Ainsi en PHP 4, il fallait écrire le code suivant pour utiliser un constructeur.

class Bar {
    function Bar() {}
}

Le constructeur était une méthode dont le nom était à l’identique celui de la classe. La version 5 de PHP a introduit le mot clé __construct pour le constructeur comme le montre le code ci-dessous. Pour des raisons de compatibilités, la façon de faire de la version PHP 4 est toujours reconnue, encore aujourd’hui.

class Bar {
    public function __construct() {}
}

PHP 5.3.3 entame à mon sens un premier virage afin de supprimer cette compatibilité. En effet les classes appartenant à un espace de noms n’auront désormais plus accès à cette possibilité. Cela va donc obliger les développeurs à utiliser les bonnes pratiques comme le montre l’exemple ci-dessous.

namespace Foo;
class Bar {
    public function Bar() {
        // treated as constructor in PHP 5.3.0-5.3.2
        // treated as regular method in PHP 5.3.3
    }
}

La question est donc : à quand l’impossibilité d’utiliser la méthode Bar comme un constructeur ?

A heure tardive post orienté informatique. Aujourd’hui je vais vous présenter quelques astuces (tips en anglais) de langage permettant de gagner de la place, de ne pas rallonger inutilement le code, d’éviter des erreurs basiques… La liste n’est évidemment pas exhaustive mais cela pourra toujours vous aider de les connaître. Ces astuces ne s’appliquent d’ailleurs pas uniquement au PHP.

Bien utiliser les expressions booléennes

Que l’informaticien, développeur… qui n’a pas eu un jour à abuser des if/elseif/else lève le doigt. Il est nécessaire d’optimiser ces codes pour éviter qu’ils prennent trois kilomètres de long.

/*Boolean Expressions optimization*/
if ($a == true) {
    if ($a == true) {
        print "coucou";
    }
    else if($b == true) {
        print "coucou";
    }
}

Le code ci-dessus devrait être le suivant.

/*Boolean Expressions optimization*/
if ($a && ($b || $c)) {
    print "coucou";
}

Utiliser for à la place de while

/*Use for instead of while*/
$i = 0;
while($i < 18) {
    /*SOMETHING TODO*/
    $i++;
}
/*Shorter*/
for($i = 0; $i < 18; $i++) {
    /*SOMETHING TODO*/
}

Utiliser la récursivité

La récursivité n’est pas toujours bien comprise ni utilisée. Une mauvaise utilisation amène très vite à des programmes qui tournent en boucle dans le vide. Le principe de la récursivité est d’effectuer le même traitement sur un élément. Ci-dessous se trouve la célèbre suite de Fibonaci

/*Write recursively*/
function fibonacci($n) {
    $f1 = 1;
    $f2 = 0;
    $total = 0;
    if( $n == 0 || $n == 1)
        return $n;
    for($i = 2; $i <= $n; $i++) {
        $fib = $f1 + $f2;
        $f2 = $f1;
        $f1 = $fib;
    }
    return $fib;
}
/*Shorter*/
function fibonacci($n) {
    if ($n <= 2) return 1;
    else return fibonacci($n-1) + fibonacci($n-2);
}

L’opérateur ternaire

Je parlais plus haut de réduction du nombre de lignes de code lors de l’utilisation des if. Il est possible de réduire encore plus avec l’opérateur ternaire. Celui permet d’écrire un if/else sur un seule et unique ligne.

/*Ternary Operator*/
if ($iCompteur > 550)
    $bBool = true;
else
    $bBool = false;
/*Shorter*/
$bBool = $iCompteur > 550 ? true : false;
/*Even shorter*/
$bBool = $iCompteur > 550;

Combinaison arithmétique et opérateurs

Il s’agit sans doute de l’astuce la plus connue et utilisée. Elle permet d’identifier tout de suite ce qui est effectué.

/*Combination Arithmetic and Assignment Operators*/
$iCompteur = $iCompteur + 1000;
/*Shorter*/
$iCompteur += 1000;

Il en existe d’ailleurs un certain nombre qu’il faut connaître.

/*Combination Arithmetic and Assignment Operators*/
+= Addition
-= Soustraction
/= Division
*= Multiplication
%= Modulo
.= Concatènation
++ Incrémentation de 1
-- Diminution de 1
|= Opérateur logique ou
&= Opérateur logique et
^= Opérateur logique ou exclusif

Sens d’écriture du if

Entre le test et l’assignation à une variable, il n’existe dans la plupart des langages qu’un caractère de différence. Il est très facile de l’oublier et ainsi de générer une assignation alors qu’on voulait écrire une expression booléenne.

/*Test*/
if ($a == 1) echo "coucou";
/*Setting the variable $a to 1*/
if ($a = 1) echo "coucou";
/*Could be written this way to avoid the mistake */
if (1 == $a) echo "coucou";
/*The following code would generate a fatal error you would detect*/
if (1 = $a) echo "coucou";