PHP 7.1 : Bilan un an après la sortie de PHP 7.0

La version RC 5 de PHP 7.1 🔗 est sortie il y a quelques jours, ce qui annonce une version stable pour très bientôt mais faisons plutôt le bilan des 1 an de la version 7.0.

PHP 7.0, un an déjà

Prometteuse et tant attendue, PHP 7.0 marque un tournant du langage de programmation web le plus populaire. Il a su se refaire une beauté et pour cause son moteur a complètement été revue, une véritable cure de jouvence.

Ne nous le cachons pas, PHP 7.0 n’est pas une énorme révolution pour les développeurs comparés au passage de la version 4 à la version 5. Mais pour la partie système, c’est un vrai délice.

Imaginez un instant que vous vouliez améliorer les performances de vos applications web en divisant les temps de réponse par 2 et en multipliant les nombres de transactions possibles par 2, juste en faisant un upgrade de PHP sur votre serveur ?

PHP 7.0 répond à cette question et apporte son lot de nouveautés : nouvelle version du Zend Engine, gestion des erreurs, typages scalaires et return type, différentes modifications destinées à améliorer la cohérence du langage.

Nouvelle version du Zend Engine

Si vous avez testé la version 7.0 de PHP sur votre environnement web, vous avez sans doute remarqué des performances notables de vos applications web. Selon les applications, on constate en effet une amélioration de celles-ci qui peut aller de 30% jusqu’à 100%, sur le papier bien entendu. L’exemple de WordPress, une plateforme CMS Open Source, est souvent repris en exemple et mis en évidence pour illustrer les chiffres :

wordpress-php-7-0

Comme on peut le remarquer, PHP 7 traite plus de 2 fois plus de transactions. Ces améliorations au niveau des performances s’accompagnent d’une meilleure gestion multi-threads ainsi que d’un meilleur support des plateformes 64 bits.

Gestion des erreurs

La gestion des erreurs a été revu dans sa globalité. Il faut savoir que dans la version 5 de PHP certaines erreurs étaient « interceptables » grâce au mécanisme des exceptions alors que d’autres ne l’étaient pas.

Le problème c’est que PHP à une tendance à mettre en avant des erreurs (particulièrement les erreurs fatales) qui mettaient fin à l’exécution d’un script. C’est un problème que vous avez certainement rencontré lorsque vous devez exécuter des scripts particulièrement longs. Fort heureusement, PHP 7.0 a su faire évoluer cette gestion des erreurs : une grande partie des erreurs fatales de PHP ont été converties en exceptions, il est donc possible de les intercepter et de les traiter.

Typages scalaires, return type et un nouvel opérateur

Un avantage pour certains, un inconvénient pour d’autres. PHP tient une réputation de typage très faible. PHP 7 se réconcilie avec les développeurs en lui permettant d’imposer ou non du typage sur certains éléments du langage. Vous avez désormais la possibilité de définir des typehints scalaires. En clair, il est désormais possible de typer les paramètres d’une fonction dans sa définition. Voici un exemple :

<?php
function multiplication(int $a, int $b) {
    return $a * $b;
}

var_dump( multiplication(10, 10) ); // int(100)

Tentez de passer un « string » à la place d’un entier et vous aurez droit à un beau message d’erreur en retour.

Mais ça ne s’arrête pas là ! Il est également possible de typer le « return » d’une fonction. Reprenons notre exemple :

<?php
function multiplication(int $a, int $b) : int {
    return $a * $b;
}

Si par malheur votre fonction retourne autre chose qu’un entier, vous aurez droit à un beau message d’erreur de ce genre :

TypeError: Return value of multiplication() must be of the type int, string returned

Un nouvel opérateur a également fait son apparition et il s’agit de « [expr] <=> [expr] ». Il retourne 0 si les 2 expressions sont égales, 1 si l’expression de gauche est plus grande et -1 si l’expression de droite est plus grande :

<?php

echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1

echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1

echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1

Gérer la souplesse de PHP

Par défaut PHP tentera de convertir les données qui lui ont été transmises pour respecter le typage demandé. Si vous souhaitez que PHP travaille en mode de typage plus strict, une nouvelle option est disponible pour l’instruction declare() :

<?php
declare(strict_types=1);

Différentes modifications destinées à améliorer la cohérence du langage

La version 7 de PHP n’a pas fait non plus l’impasse sur des améliorations de la cohérence du langage. Plusieurs modifications ont été intégrées :

Les balises d’ouvertures alternatives telles que <% ou <%= ne sont supportées
Il n’est plus possible d’utiliser plusieurs « default » dans un switch
Les « use » peuvent être imbriqué pour simplifier l’appel aux namespaces
L’utilisation des constructeurs de classe à la façon PHP 4, ou le constructeur est une méthode du même nom que la classe, lèvera désormais un avertissement indiquant qu’ils sont obsolètes
Le niveau d’avertissements E_STRICT a été supprime et les levées d’erreurs correspondantes ont été reclassifiées vers d’autres niveaux, comme E_DEPRECATED ou E_WARNING.

Avez-vous déjà migré vers la version 7.0 ?

D’après w3techs.com 🔗, PHP 7 ne représente aujourd’hui que 1,5 % des installations actives de PHP, contre 97,4 % de PHP 5. Cette nouvelle version est prometteuse mais nous sommes peu à avoir passé le cap. Je vous assure que passer de la version 5.6 à une version 7.0 vaut vraiment le coup. Néanmoins, il se peut que vos applications web ne soient pas 100 % fonctionnelles sur la version 7.0. Heureusement, il existe un outil permettant d’analyser votre code pour trouver toutes les incompatibilités entre la version 5 et la 7. Il se nomme « phan » et il a été développé par la société Etsy. Grâce à lui, vous serez en mesure de repérer rapidement vos parties de codes à adapter.

PHP 7.1 écoute sa communauté

Les nouvelles évolutions à venir sont dues aux retours et à la participation de la communauté. La version 7.1 continue son amélioration avec le typage.

Le type nullable est désormais disponible comme paramètre d’une fonction. Il suffit de positionner le symbole « ? » devant le paramètre souhaité :

<?php
function null_accepte(?int $val) {
    var_dump($val);
}

null_accepte(100); // int(100) null_accepte(null); // NULL

Cette syntaxe s’étend également sur les valeurs de retour d’une fonction ou d’une méthode.

Il est maintenant possible d’indiquer à une fonction ou une méthode qu’elle ne retourne aucune valeur grâce au mot-clé « void ». Voici la syntaxe :

<?php
function ne_retourne_rien() : void {
    // Cette fonction ne retourne rien
}

Par contre il est toujours possible de faire un « return » seul pour quitter votre fonction.

Toujours dans la continuité, la cohérence du langage continue. La fonction list() a été amélioré. Vous pouvez désormais spécifier les clés des données que vous voulez extraire.

<?php

$array = ['firstname' => "Gaëtan", 'name' => 'Cottrez', 'age' => 28];

list ('firstname' => $a, 'name' => $b) = $array;

Il est aussi possible d’utiliser des indices négatifs dans vos manipulations de chaines de caractères :

<?php

$str = "Gaëtan";
var_dump($str[-2]); // string(1) "a"

$str = "Gaë.an";
$str[-3] = 't';
var_dump($str); // string(6) "Gaëtan"

La gestion d’erreurs subit également de nouvelles améliorations. Il est maintenant possible d’attraper plusieurs types d’exceptions avec un seul « catch ». l’utilisation de chaînes non numériques dans des calculs provoquera à un message de type « notice ».

Et après PHP 7.1 ?

Bien évidemment la 7.2 surement dans un an comme pour la 7.1, ce qui serait un bon rythme je pense et laisserait aisément la communauté à tester, rapporter et contribuer aux améliorations. Soyons honnête la version a tout juste un an et il est encore trop pour parler de PHP 8.0.

PHP 7.1 : Bilan un an après la sortie de PHP 7.0

Table des matières