Publié le 25 novembre 2021, PHP 8.1 est une mise à jour majeure du langage PHP.
Elle contient plusieurs nouvelles fonctionnalités, des améliorations et quelques changements.
Parmi les points d’évolutions phares de PHP 8.1, on retrouve le support des Énumérations, les Fibers, les types Never, Return, les types intersection, les propriétés en lecture seule, la syntaxe callable de première classe et bien d’autres...
Nouvelles fonctionnalités PHP 8.1
PHP 8.1 ajoute de nouvelles fonctionnalités telles que les Enums, une des fonctionnalités les plus attendues de PHP.
En plus, il ajoute les Fibers, ce qui constitue un pas significatif vers les applications concurrentes de PHP. Plaçant ainsi PHP au dessus du traditionnel schéma requête-réponse.
1. L'ajoutdes Enumérations
L'ajout des enums est une amélioration significative de PHP 8.1.
L'avantage des énumérations est qu'ils représentent une collection de valeurs constantes, mais surtout, ces valeurs peuvent être typées.
Par ailleurs, l’utilisation d’énumération au lieu d'un ensemble de constantes, permet de bénéficier d'une validation immédiate.
class Status
{
const DRAFT = 'draft';
const PUBLISHED = 'published';
const ARCHIVED = 'archived';
}
function acceptStatus(string $status) {...}
enum Status
{
case Draft;
case Published;
case Archived;
}
function acceptStatus(Status $status) {...}
2. La propriété en lecture seule
Les propriétés en lecture seule ne peuvent être modifiées après initialisation. Ce qui signifie qu'elles ne peuvent être écrites qu'une seule fois.
Elles constituent un excellent moyen de modéliser les objets de valeur et les objets de transfert de données.
class BlogData
{
private Status $status;
public function __construct(Status $status)
{
$this->status = $status;
}
public function getStatus(): Status
{
return $this->status;
}
}
class BlogData
{
public readonly Status $status;
public function __construct(Status $status)
{
$this->status = $status;
}
}
3. La Syntaxe callablede première classe
Avec PHP 8.1, il est désormais possible d'obtenir une référence à n'importe quelle fonction.
C'est ce qu'on appelle la syntaxe callable de première classe.
$foo = [$this, 'foo'];
$fn = Closure::fromCallable('strlen');
$foo = $this->foo(...);
$fn = strlen(...);
4. Le “new” dans les Initialisateurs
Les objets peuvent désormais être utilisés comme valeurs de paramètres par défaut, variables statiques et constantes globales, ainsi que dans les arguments d'attributs.
class Service
{
private Logger $logger;
public function __construct(
?Logger $logger = null,
) {
$this->logger = $logger ?? new NullLogger();
}
}
class Service
{
private Logger $logger;
public function __construct(
Logger $logger = new NullLogger(),
) {
$this->logger = $logger;
}
}
Ce qui signifie qu’il est possible d'utiliser le mot clé new dans les définitions de fonctions comme paramètre par défaut, ainsi que dans les arguments d'attributs et à d'autres endroits.
Cette nouveauté du PHP 8.1 permet d'exploiter des attributs imbriqués.
class User
{
/**
* @Assert\All({
* @Assert\NotNull,
* @Assert\Length(min=5)
* })
*/
public string $name = '';
}
class User
{
#[\Assert\All(
new \Assert\NotNull,
new \Assert\Length(min: 6))
]
public string $name = '';
}
5. Des types d'intersection purs
PHP 8.1, rend possible l’utilisation des types d'intersection lorsqu'une valeur doit satisfaire plusieurs contraintes de type en même temps.
Si vous connaissez les types union en PHP 8.0, alors les types intersection sont une fonctionnalité similaire.
Alors que les types union requièrent que l'entrée soit un des types donnés, les types intersection exigent que l'entrée soit tous des types spécifiés.
Les types intersection sont particulièrement utiles lorsque vous travaillez avec plusieurs interfaces.
NB : Il n'est actuellement pas possible de combiner les types intersection et union, par exemple A&B|C.
function count_and_iterate(Iterator $value) {
if (!($value instanceof Countable)) {
throw new TypeError('value must be Countable');
}
foreach ($value as $val) {
echo $val;
}
count($value);
}
function count_and_iterate(Iterator&Countable $value) {
foreach ($value as $val) {
echo $val;
}
count($value);
}
6. Nouveau type never
Une fonction ou une méthode déclarée avec le type never, indique qu'elle ne changera pas de valeur et qu'elle lancera une exception ou mettra fin à l'exécution du script par un appel à die(), exit(), trigger_error(), ou quelque chose de similaire.
Le type never peut donc être utilisé pour indiquer qu'une fonction va réellement arrêter le déroulement du programme.
Ça peut être fait en lançant une exception, en appelant un “exit” ou d'autres fonctions similaires.
NB : never diffère de void en ce sens que void permet au programme de continuer.
function redirect(string $uri) {
header('Location: ' . $uri);
exit();
}
function redirectToLoginPage() {
redirect('/login');
echo 'Hello'; // <- dead code
}
function redirect(string $uri): never {
header('Location: ' . $uri);
exit();
}
function redirectToLoginPage(): never {
redirect('/login');
echo 'Hello'; // <- dead code detected by static analysis
}
7. Les constantes finales de la classe
Il est possible de déclarer des constantes de classe finales, afin qu'elles ne soient pas surchargées à l’intérieur des classes filles.
class Foo
{
public const XX = "foo";
}
class Bar extends Foo
{
public const XX = "bar"; // No error
}
class Foo
{
final public const XX = "foo";
}
class Bar extends Foo
{
public const XX = "bar"; // Fatal error
}
8. Une notation explicite des chiffres octaux
Avec le PHP 8.1, il est maintenant possible d'écrire les nombres octaux avec le préfixe explicite 0o.
Toutefois, la notation précédente en préfixant un nombre avec 0 fonctionne toujours.
016 === 16; // false because `016` is octal for `14` and it's confusing
016 === 14; // true
0o16 === 16; // false — not confusing with explicit notation
0o16 === 14; // true
9. Les Fibers alias "green threads"
Les Fibers sont un mécanisme de bas niveau pour gérer le parallélisme.
Elles permettent de créer des blocs de code qui peuvent être interrompus et repris comme les générateurs, mais de n'importe où dans la pile.
$httpClient->request('https://example.com/')
->then(function (Response $response) {
return $response->getBody()->buffer();
})
->then(function (string $responseBody) {
print json_decode($responseBody)['code'];
});
$response = $httpClient->request('https://example.com/');
print json_decode($response->getBody()->buffer())['code'];
Les Fibers elles-mêmes ne fournissent pas automatiquement de la concurrence, il faut toujours une boucle d'événement.
Cependant, elles permettent aux implémentations bloquantes et non bloquantes de partager le même API.
10. Décompression de tableaux avec clés de type chaîne
PHP supportait déjà depuis la version 7.4, le dépaquetage dans les tableaux avec l'opérateur spread, mais seulement si les tableaux avaient des clés entières.
Avec PHP 8.1, il est possible de décompresser des tableaux avec des clés de type chaîne.
La raison pour laquelle les chaînes de caractères n'étaient pas supportées par les versions précédentes étaient l’absence de consensus sur le mode de fusion des tableaux dupliqués.
Ce problème est résolu avec la sémantique de array_merge :
$arrayA = ['a' => 1];
$arrayB = ['b' => 2];
$result = array_merge(['a' => 0], $arrayA, $arrayB);
// ['a' => 1, 'b' => 2]
$arrayA = ['a' => 1];
$arrayB = ['b' => 2];
$result = ['a' => 0, ...$arrayA, ...$arrayB];
// ['a' => 1, 'b' => 2]
Amélioration des performances
L’application de démonstration Symfony montre un temps de requête de 25 exécutions consécutives, 250 requêtes (sec) par rapport à PHP 8.0.
Un meilleur temps d’exécution et une meilleure méthode.
Le résultat du test de performance (par rapport à PHP 8.0) Montre ainsi :
- 23.0% de gain de vitesse pour Symfony Demo
- 3.5% de gain de vitesse pour WordPress
Ces performances de PHP 8.1 sont liées aux fonctionnalités suivantes :
- Backend JIT pour ARM64 (AArch64)
- Cache d'héritage (évite de relier les classes à chaque requête)
- Résolution rapide des noms de classes (évite les minuscules et la recherche par hachage)
- Amélioration des performances de timelib et ext/date
- Amélioration des itérateurs du système de fichiers SPL
- Optimisations de serialize/unserialize
- Optimisation de certaines fonctions internes (get_declared_classes(), explode(), strtr(), strnatcmp(), dechex())
- Améliorations et corrections JIT
Nouvelles classes, interfaces et fonctions
-
Nouvel attribut #[ReturnTypeWillChange].
#[\ReturnTypeWillChange] est un nouvel attribut introduit en PHP 8.1, qui signale qu'un type de retour provisoire non concordant ne doit pas émettre de notice de dépréciation.
Les versions de PHP antérieures à 8.0 analysent la syntaxe de l'attribut comme un commentaire de code, et ne provoque aucune erreur de syntaxe.
L'ajout de l'attribut #[\ReturnTypeWillChange] à une méthode de classe ne cause aucun problème, mais omet la notice de dépréciation en PHP 8.1.
-
Nouvelles fonctions fsync et fdatasync.
PHP 8.1 ajoute les fonctions fsync et fdatasync pour forcer la synchronisation des changements de fichiers sur le disque et s'assurer que les tampons d'écriture du système d'exploitation ont été vidés avant de revenir.
-
Nouvelle fonction array_is_list.
La fonction array_is_list de PHP 8.1, permet de retourner vrai si le tableau donné est une liste sémantique de valeurs ; un tableau dont toutes les clés sont des entiers, les clés commencent à 0, sans espace entre elles.
La fonction array_is_list renvoie également vrai sur les tableaux vides.
-
Nouvelles fonctions Sodium XChaCha20.
L'extension Sodium de PHP 8.1 fournit un algorithme de cryptage de flux XChaCha20, disponible depuis libsodium 1.0.12.
XChaCha20 est un algorithme de chiffrement par flux et est une variante de l'algorithme ChaCha20.
Dépréciations et ruptures de compatibilité ascendante
Les changements rétrogrades incompatibles concernent :
- Le passage de null à des paramètres de fonctions internes non-nullables est déprécié.
- Types de retour provisoires dans les méthodes des classes intégrées de PHP
- L'interface Serializable est dépréciée.
- Les fonctions en/decode des entités HTML traitent les guillemets simples et les substituts par défaut.
- Restrictions de la variable $GLOBALS.
- MySQLi : Le mode d'erreur par défaut est défini sur les exceptions.
- La conversion implicite incompatible de float en int est dépréciée.
- Extension finfo : les ressources file_info ont migré vers les objets finfo existants.
- IMAP : les ressources imap ont migré vers les objets de la classe IMAP\Connection.
- Extension FTP : Les ressources de connexion ont migré vers les objets de la classe FTP\Connection.
- Extension GD : Les identifiants de police ont migré vers les objets de classe GdFont.
- LDAP : les ressources ont migré vers les objets LDAP\Connection, LDAP\Result, et LDAP\ResultEntry.
- PostgreSQL : migration des ressources vers les objets PgSql\Connection, PgSql\Result, et PgSql\Lob.
- Pspell : ressources pspell, pspell config migrées vers les objets de classe PSpell\Dictionary, PSpell\Config.
De meilleures performances, de meilleure syntaxe, une meilleure sécurité des types.
Pour migrer vers PHP 8.1,suivez la procédure de mise à niveau habituelle de Camoo.
Ensuite, rendez-vous sur votre espace client !
Bonne Migration !
Vous avez des questions ou besoin d'assistance ? Contactez notre service client !
Commentaires
0 commentaire
Vous devez vous connecter pour laisser un commentaire.