Les nouveautés de PHP 8.6, avec du code qu'on écrit vraiment
PHP 8.6 sort aujourd'hui. Sa nouveauté phare, l'application partielle de fonctions, paraît anecdotique sur le papier. Elle change pourtant la façon d'écrire beaucoup de petits morceaux de code, et elle rend enfin pratique l'opérateur pipe arrivé avec PHP 8.5. Le reste de la version est fait d'ajouts plus modestes, mais qui suppriment chacun un bout de code qu'on réécrit dans tous les projets.
J'ai compilé PHP 8.6 depuis la branche de la version pour vérifier chaque exemple de cet article. Je vous montre à chaque fois le code d'avant, puis celui d'après.
L'application partielle : ? à la place d'une fonction fléchée
Combien de fois avez-vous écrit une fonction fléchée qui ne fait que passer son paramètre à une autre fonction ?
$bio = array_filter($references, fn (string $reference) => str_starts_with($reference, 'BIO-')); $prix = array_map(fn (float $montant) => sprintf('%.2f €', $montant), $montants);
En PHP 8.6, on appelle la fonction en mettant ? à la place de l'argument manquant. On n'obtient pas un résultat, mais une closure qui attend cet argument :
$bio = array_filter($references, str_starts_with(?, 'BIO-')); $prix = array_map(sprintf('%.2f €', ?), $montants);
Le ? peut se placer n'importe où dans la liste, et il peut y en avoir plusieurs. ... laisse ouverts tous les arguments restants : c'est la syntaxe strlen(...) de PHP 8.1, qui devient un cas particulier de la même idée.
Avec array_map(), c'est aussi plus rapide. Un array_map() dont la fonction de rappel est une application partielle est compilé en boucle foreach : ni closure intermédiaire, ni appel de fonction utilisateur à chaque élément.
Le piège : les arguments sont évalués tout de suite
Une closure partielle n'est pas une fonction fléchée déguisée. Les arguments déjà fournis sont évalués au moment où elle est créée, pas au moment où elle est appelée :
$journaliser = $this->ecrire(?, date('H:i:s')); // … dix minutes plus tard $journaliser('Commande validée'); // l'heure est toujours celle de la création
Avec fn ($message) => $this->ecrire($message, date('H:i:s')), l'heure était calculée à chaque appel. En passant à l'application partielle, on fige donc la valeur. La règle à retenir : ne fixez par avance que les valeurs qui ne changent pas (un niveau de log, un séparateur), et laissez un ? pour tout ce qui dépend du moment de l'appel.
Le pipe de PHP 8.5 devient lisible
PHP 8.5 a apporté l'opérateur |>, qui enchaîne les appels de fonctions. Mais il ne passe qu'un seul argument à la fonction suivante. Dès qu'une étape en demandait deux, il fallait une fonction fléchée, entre parenthèses en plus :
$slug = $titre |> trim(...) |> strtolower(...) |> (fn (string $texte) => preg_replace('/[^a-z0-9]+/', '-', $texte)) |> (fn (string $texte) => trim($texte, '-'));
Avec l'application partielle, chaque étape tient sur une ligne :
$slug = $titre |> trim(...) |> strtolower(...) |> preg_replace('/[^a-z0-9]+/', '-', ?) |> trim(?, '-');
Ce n'est pas seulement plus court. Le compilateur reconnaît un ? unique juste après |> et compile l'étape en appel direct : aucune closure n'est créée, je l'ai vérifié dans les opcodes.
clamp() remplace max(min())
Ramener une valeur entre deux bornes s'écrivait max(0, min(20, $note)), une expression qu'il faut relire deux fois pour savoir quelle borne est laquelle. PHP 8.6 ajoute clamp() :
$note = clamp($note, min: 0, max: 20);
clamp() compare comme min() et max(), donc elle fonctionne aussi avec des dates. Elle lève une ValueError si la borne basse dépasse la borne haute. C'est un vrai garde-fou : max(min()) renvoyait sans rien dire l'une des deux bornes. Attention à la pagination d'une liste vide, où la dernière page vaut 0 et passe sous la borne basse de 1.
Time\Duration : un délai qui a une unité
$timeout = 30 : des secondes ou des millisecondes ? La nouvelle classe Time\Duration porte son unité :
use Time\Duration; $base = Duration::fromMilliseconds(100); $delai = min(Duration::fromSeconds(30), $base->multiplyBy(2 ** $tentative));
L'objet est immuable : add(), sub(), multiplyBy() et divideBy() renvoient une nouvelle durée. Les opérateurs de comparaison fonctionnent, ainsi que min(), max() et clamp(). Duration::fromIso8601DurationString('PT1M30S') lit une durée écrite dans un fichier de configuration. Seule la partie horaire du format ISO 8601 est acceptée : PT36H passe, mais P1D lève une Time\TimeException.
Les propriétés readonly ont une valeur par défaut
Jusqu'ici, une propriété readonly ne pouvait pas déclarer de valeur par défaut : il fallait passer par le constructeur. En PHP 8.6, elle peut :
final class Requete { public readonly string $methode = 'GET'; public readonly int $tentatives = 3; public function __construct(public readonly string $url) { } public function avecMethode(string $methode): static { return clone($this, ['methode' => $methode]); } }
Combinée au clone() avec propriétés de PHP 8.5, elle permet d'écrire un objet valeur avec des méthodes avec…() sans constructeur à rallonge.
#[\Override] vaut aussi pour les constantes
L'attribut #[\Override] (PHP 8.3) garantit qu'une méthode redéfinit bien une méthode parente. En 8.6, il s'applique aussi aux constantes de classe :
final class ExportExcel extends Export { #[\Override] protected const string DELIMITEUR = ';'; }
Le jour où la classe mère renomme DELIMITEUR, PHP refuse de compiler : « ExportExcel::DELIMITEUR has #[\Override] attribute, but no matching parent constant exists ». Sans l'attribut, la classe fille aurait gardé une constante que plus personne ne lit, et l'export serait reparti avec la valeur par défaut sans prévenir.
SortDirection, une énumération pour le sens de tri
Un paramètre string $sens = 'asc' accepte aussi 'ASC', 'croissant' ou une faute de frappe. PHP 8.6 fournit une énumération globale, SortDirection, avec deux cas : Ascending et Descending. Un match sur cette énumération n'a pas besoin de branche default, et une valeur inconnue ne peut plus arriver jusqu'à une clause ORDER BY.
Les flux peuvent lever des exceptions
fopen() sur un fichier absent émet un avertissement et renvoie false. On finit avec un @ et un test du retour, ou un gestionnaire d'erreurs qui transforme l'avertissement. PHP 8.6 ajoute un mode d'erreur aux contextes de flux :
$contexte = stream_context_create(['stream' => ['error_mode' => StreamErrorMode::Exception]]); try { $fichier = fopen($chemin, 'r', false, $contexte); } catch (StreamException $erreur) { // $erreur->getErrors() : la liste des erreurs, avec un code (StreamErrorCode) et le wrapper concerné }
En mode exception, plus aucun avertissement n'est émis : votre gestionnaire d'erreurs ne voit rien passer. Petit détail utile : pour un fichier introuvable, le code est OpenFailed, pas NotFound.
Construire une URL avec UrlBuilder
PHP 8.5 a apporté l'extension URI, qui analyse les URL selon la norme WHATWG ou la RFC 3986. PHP 8.6 lui ajoute Uri\WhatWg\UrlBuilder, pour construire une URL morceau par morceau au lieu de concaténer des chaînes :
use Uri\WhatWg\UrlBuilder; $lien = new UrlBuilder() ->setScheme('https') ->setHost('colis.example') ->setPath('/suivi/'.rawurlencode($numero)) ->setQuery(http_build_query(['lang' => 'fr'])) ->build() ->toAsciiString();
UrlBuilder encode ce que la norme WHATWG impose (un espace dans le chemin devient %20) et lève une Uri\WhatWg\InvalidUrlException si le résultat n'est pas une URL valide. build() accepte aussi une URL de base, pour résoudre un chemin relatif comme le ferait un navigateur.
Attention, setPath() n'encode ni / ni %, et résout les .. : /suivi/../admin devient /admin. Un segment venu de l'utilisateur se passe donc toujours à rawurlencode().
La réflexion connaît private(set) et readonly
Un hydrateur maison qui vérifie isPublic() avant d'écrire une propriété se trompe depuis PHP 8.4 : une propriété public private(set) est publique en lecture, mais pas en écriture. PHP 8.6 ajoute ReflectionProperty::isWritable() et isReadable(), qui répondent pour une portée donnée :
final class Adherent { public private(set) int $points = 0; } $propriete = new ReflectionProperty($adherent, 'points'); $propriete->isPublic(); // true : lisible de partout $propriete->isWritable(null, $adherent); // false : écriture réservée à la classe
Le premier argument est la portée d'où l'on écrit (null pour du code extérieur à toute classe). Le second est l'objet, nécessaire pour savoir si une propriété readonly a déjà été initialisée.
Ce qui devient déprécié
La liste est longue. Voici ce que l'on croise le plus dans du code existant :
returndans un blocfinally, qui avalait silencieusement l'exception en cours ;- une valeur renvoyée par
__construct()ou__destruct(), que PHP ignorait de toute façon ; - les alias
is_integer(),is_long(),is_double()etdoubleval(), à remplacer paris_int(),is_float()etfloatval(); spl_object_hash(), à remplacer parspl_object_id(), ou par uneWeakMappour associer des données à un objet ;- le troisième argument de
define(), les méthodes de tri d'ArrayIterator(asort(),ksort()…) et les méthodes CSV deSplFileObject(fgetcsv(),fputcsv()).
Une dépréciation ne casse rien aujourd'hui, mais elle annonce une suppression dans une prochaine version majeure. Lancez vos tests avec error_reporting=E_ALL pour les voir. Certaines (return dans finally) sont émises dès la compilation, avant même l'exécution du code : avec OPcache, elles n'apparaissent qu'à la première compilation du fichier.
Pour pratiquer
Chacune de ces nouveautés aura son exercice dans la section Pratique, en PHP sans framework, à partir du 4 décembre : on part du code tel qu'on l'écrit aujourd'hui, et on le réécrit avec PHP 8.6. Ils seront rassemblés au fur et à mesure sur la page des nouveautés de PHP 8.6.