Sommaire
Nouvelles fonctionnalités
Syntaxe
Les unions de types
PHP continue sa route vers un langage fortement typé, en ajoutant le support des unions de types dans les spécificateurs de type de paramètres, de variables ou de retour de fonction.
L’exemple de la RFC :
class Number {
private int|float $number;
public function setNumber(int|float $number): void {
$this->number = $number;
}
public function getNumber(): int|float {
return $this->number;
}
}
Cela permet de mettre des informations de type à des endroits où l’on ne pouvait pas en mettre, lorsque plusieurs types différents sont acceptés ou retournés.
Type « mixed »
Toujours à propos des types, le type mixed a été ajouté (cf. RFC). Il indique qu’une variable peut être de n’importe quel type pris en charge par PHP.
Ça peut sembler idiot puisque ça revient au même que de ne pas mettre d’indication de type, mais ça permet au développeur de l’indiquer explicitement, et il existe de nombreux cas de figure où il est tout à fait normal d’accepter tous les types (pour une fonction de sérialisation, par exemple). Cela peut aussi servir à indiquer qu’une fonction doit retourner quelque chose, c’est donc le contraire de :void qui indique l’absence de retour.
Aussi le mot-clé mixed était déjà largement utilisé dans la documentation de PHP.
Type de retour « static »
Puisqu’on parle de typage, il est maintenant possible d’indiquer « static » comme type de retour pour une méthode. Cela signifie qu’elle renvoie une instance de la classe sur laquelle la méthode est appelée. À noter qu’il existait déjà le type de retour « self » pour indiquer qu’une méthode renvoie une instance de la classe à laquelle elle appartient, ce qui n’est pas la même chose. Voir la notion PHP de « late static binding » [RFC].
Exemple :
class Test {
public function create(): static {
return new static();
}
}
Les attributs
Largement la plus grosse source de débats internes pour cette version, les attributs ont fait leur apparition.
Un attribut, parfois appelé annotation dans d’autres langages, est une métadonnée qui peut être ajoutée sur une fonction, une classe, un paramètre, une propriété… Cette métadonnée est ensuite disponible par réflexion.
Après être passée par <> et @@Attribute, c’est finalement la syntaxe #[Attribute] qui a été choisie au bout de quatre RFC, syntaxe déjà utilisée par Rust. La notation @Attribute utilisée dans beaucoup d’autres langages n’était pas disponible, puisque l’opérateur @ existe déjà en PHP et sert à ignorer les erreurs.
RFC :
Les paramètres nommés
Un autre gros morceau de cette version est la prise en charge des paramètres nommés, ce qui signifie qu’il est possible d’indiquer la valeur d’un paramètre de fonction par son nom plutôt que par sa position.
Exemples tirés de la RFC :
htmlspecialchars($string, double_encode: false);
// Au lieu de
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
array_fill(start_index: 0, num: 100, value: 50);
// Au lieu de
array_fill(0, 100, 50);
// L’ordre n’est plus important, cette version est équivalente
array_fill(value: 50, num: 100, start_index: 0);
Ce changement signifie que les noms des paramètres font maintenant partie de la signature des fonctions, et que renommer un paramètre de fonction peut casser du code qui utilise la fonction. Pour cette raison un gros travail d’amélioration et d’uniformisation des noms de paramètres a été fait pour PHP 8, et dans les versions suivantes un renommage sera considéré comme cassant la compatibilité descendante [RFC].
La promotion de paramètres constructeurs
Dans le but de simplifier l’écriture de classes simples servant simplement de schéma pour des objets contenant des données, et pour encourager leur utilisation plutôt que celle de tableaux, il est maintenant possible de déclarer les propriétés d’une classe directement dans les paramètres du constructeur, afin de ne pas avoir à les écrire deux fois [RFC].
Exemple :
// Avant
class Point {
public float $x;
public float $y;
public float $z;
public function __construct(
float $x = 0.0,
float $y = 0.0,
float $z = 0.0,
) {
$this->x = $x;
$this->y = $y;
$this->z = $z;
}
}
// En PHP>=8.0
class Point {
public function __construct(
public float $x = 0.0,
public float $y = 0.0,
public float $z = 0.0,
) {}
}
À noter que cette nouveauté se marie particulièrement bien avec les paramètres nommés :
class Circle {
public function __construct(
public float $x = 0.0,
public float $y = 0.0,
public float $z = 0.0,
public float $r = 1.0,
public string $name = '',
public string $color = 'black',
) {}
}
$c1 = new Circle(x:12, y:13, r:5, name:'C1');
Opérateur « nullsafe »
Un nouvel opérateur ?-> a été ajouté [RFC]. Il permet d’appeler une fonction ou de récupérer une propriété de l’objet contenu dans la variable sans déclencher d’erreur si la variable est nulle. Cela permet par exemple de chaîner les appels de fonctions en autorisant une valeur nulle à plusieurs endroits de la chaîne.
Exemple :
// Le code suivant
$country = null;
if ($session !== null) {
$user = $session->user;
if ($user !== null) {
$address = $user->getAddress();
if ($address !== null) {
$country = $address->country;
}
}
}
// Peut maintenant être écrit
$country = $session?->user?->getAddress()?->country;
Mot‑clef « match »
Le mot‑clef match a été ajouté comme alternative au switch lorsque l’on cherche à retourner une valeur depuis chaque branche.
Exemple :
// Avec switch
switch ($mot) {
case 'un':
$nombre = 1;
break;
case 'deux':
$nombre = 2;
break;
case 'trois':
$nombre = 3;
break;
default:
throw new Exception ('Mot invalide');
break;
}
// Avec match
$nombre = match ($mot) {
'un' => 1,
'deux' => 2,
'trois' => 3,
default => throw new Exception ('Mot invalide'),
};
Lisez attentivement la RFC pour la liste des subtiles différences avec switch.
Nouvelles classes et interfaces
La classe WeakMap a été ajoutée. Elle permet de gérer des correspondances avec des objets en clefs, qui n’empêchent pas ces objets d’être détruits par le ramasse‑miettes. Quand un objet est détruit, la valeur qui lui est associée est simplement retirée de la WeakMap [RFC].
Une nouvelle classe ValueError est lancée quand une méthode reçoit un paramètre du bon type mais avec une valeur inappropriée, pour différencier du cas des TypeError, qui apparaissent quand le paramètre n’a pas le bon type.
Une nouvelle interface Stringable permet de reconnaître les objets qui peuvent être transtypés en string.
Elle est automatiquement implémentée par les classes qui définissent la méthode magique __toString().
Cela permet, avec l’union des types, d’utiliser le groupe string|Stringable pour typer un paramètre qui accepte soit une chaîne de caractères, soit n’importe quel objet qui peut se transtyper en chaîne de caractères [RFC].
Autres nouveautés
- il est maintenant possible d’obtenir le nom de la classe d’un objet en utilisant
$object::class, le résultat est le même que get_class($object) [RFC] ;
-
new et instanceof peuvent maintenant être utilisés avec des expressions arbitraires, sous la forme new (expression)(...$args) et $obj instanceof (expression) [RFC] ;
- des changements ont été faits pour rendre la syntaxe des variables plus cohérentes, par exemple il est maintenant autorisé d’écrire
Foo::BAR::$baz [RFC] ;
- les traits peuvent maintenant définir des méthodes privées [RFC] ;
-
throw peut désormais être utilisé comme une expression [RFC] ;
- une virgule supplémentaire est autorisée à la fin des listes de paramètres, pour faciliter les choses quand on écrit un paramètre par ligne (notamment pour mieux versionner dans ces cas‑là) [RFC] ;
- il est maintenant possible d’écrire
catch (Exception) pour capturer une exception sans la stocker dans une variable [RFC] ;
- les méthodes privées déclarées sur une classe parente ne contraignent plus la signature des méthodes sur la classe fille (à l’exception des constructeurs finals privés) [RFC] ;
-
un nombre variable de paramètres de méthode peut maintenant être remplacé par un paramètre variadique lors de l’héritage, tant que les types sont compatibles ; ceci est par exemple possible :
class A {
public function method(int $many, string $parameters, $here) {}
}
class B extends A {
public function method(...$everything) {}
}
Bibliothèque standard
printf()
Les fonctions de la famille printf() supportent maintenant les spécificateurs de format %h et %H. Ils font pareil que %g et %G mais utilisent toujours le point comme séparateur des décimales au lieu de se fier à la régionalisation (locale) configurée via LC_NUMERIC.
Il est également maintenant possible d’utiliser * comme largeur de champ ou précision de flottant, auquel cas la largeur/précision est passée comme argument à la fonction. Passer -1 comme précision pour %g, %G, %h et %H permet de reproduire le comportement par défaut de PHP pour les flottants :
printf("%.*H", (int) ini_get("precision"), $float);
printf("%.*H", (int) ini_get("serialize_precision"), $float);
proc_open()
La fonction proc_open() gère maintenant des descripteurs de pseudo‑terminal (PTY) ; l’exemple suivant attache stdin, stdout et stderr au même PTY :
$proc = proc_open($command, [['pty'], ['pty'], ['pty']], $pipes);
proc_open() gère maintenant les sockets. L’exemple suivant attache des sockets distincts pour stdin, stdout et stderr :
$proc = proc_open($command, [['socket'], ['socket'], ['socket']], $pipes);
Contrairement aux tubes (pipes), les sockets n’ont pas de problèmes de blocage d’entrées‑sorties sous Windows. Cependant, tous les programmes ne fonctionnent pas forcément correctement avec des sockets.
Fonctions de tri
Les différentes fonctions de tri sont maintenant stables, ce qui signifie que les éléments qui sont égaux selon la fonction de comparaison conservent maintenant leur ordre relatif d’avant le tri. Il y a un léger coût en performances mais cela peut éviter les mauvaises surprises [RFC].
Nouvelles fonctions sur les chaînes de caractères
Les fonctions str_contains(), str_starts_with() et str_ends_with() ont été ajoutées, permettant de déterminer respectivement si une chaîne de caractères contient, commence par et finit par une autre chaîne. Ce sont des opérations très courantes, et s’il n’était pas difficile de les implémenter en PHP, le fait qu’il y ait plusieurs façons de faire pouvait perturber les développeurs.
RFC :
Opérations sur les tableaux
Les fonctions array_diff(), array_intersect() et leurs variations peuvent maintenant être utilisées avec un seul tableau en paramètre. Cela facilite leur utilisation avec l’opérateur ... :
// Fonctionne même si $excludes est vide
array_diff($array, ...$excludes);
// Fonctionne même si $arrays contient un seul tableau
array_intersect(...$arrays);
Extensions
Hash
Les objets HashContext peuvent maintenant être sérialisés.
OpenSSL
Ajout du prise en charge de la RFC 5652, « Cryptographic Message Syntax (CMS) », avec des fonctions pour chiffrement, déchiffrement, signature, vérification et lecture. L’API est similaire à celle pour PKCS#7 avec l’ajout de nouvelles constantes : OPENSSL_ENCODING_DER, OPENSSL_ENCODING_SMIME et OPENSSL_ENCODING_PEM.
Performances
JIT
Un compilateur à la volée (JIT — Just In Time) a été ajouté dans PHP afin de permettre, dans certains cas, d’augmenter les performances. La fonctionnalité est désactivée par défaut et n’apporte pas grand’chose dans le cadre d’application Web classiques. En revanche, pour des usages plus gourmands en calcul, par exemple un calcul de fractal qui a été utilisé pour les démos, le compilateur à la volée apporte un gain de performance très important. L’idée est donc de rendre PHP plus viable pour des usages pour lesquels il était trop lent auparavant.
