Quoi de neuf dans PHP 8.1

PHP 8.1 est actuellement en développement actif et sortira le 25 novembre 2021 . Gardez à l’esprit que cette date peut encore changer par l’équipe principale, par exemple, si elle ajoute une version bêta supplémentaire. Nous connaissons déjà les nouvelles fonctionnalités, les améliorations de performances, les modifications et les dépréciations ; alors parcourons-les un par un.

#Nouvelles fonctionnalités

Comme pour chaque version, PHP 8.1 ajoute quelques nouvelles fonctionnalités intéressantes. Gardez à l’esprit que cette liste s’allongera au cours de l’année.

#Énumérations rfc

Les énumérations seront ajoutées en PHP 8.1 ! Si vous ne savez pas à quoi ils peuvent servir, vous pouvez en savoir plus ici .

L’ajout d’énumérations serait une amélioration significative de PHP, donc je suis très impatient de voir les énumérations arriver dans PHP 8.1. Pour vous donner un aperçu rapide de ce à quoi ils ressembleront, voici un exemple de code :

enum Status {
  case Pending;
  case Active;
  case Archived;
}

Et voici comment ils seront utilisés :

class Post
{
    public function __construct(
        private Status $status = Status::Pending;
    ) {}

    public function setStatus(Status $status): void
    {
        // …
    }
}

$post->setStatus(Status::Active);

Vous pouvez trouver une analyse approfondie de l’utilisation des énumérations dans cet article .

#Fibres rfc

Les fibres – alias “fils verts” – sont un mécanisme de bas niveau pour gérer le parallélisme. Vous ne les utiliserez probablement pas directement dans vos applications, mais des frameworks comme Amphp et ReactPHP les utiliseront largement.

Voici un exemple simple d’utilisation de fibres :

$fiber = new Fiber(function (): void {
    $valueAfterResuming = Fiber::suspend('after suspending');
    
    // … 
});
 
$valueAfterSuspending = $fiber->start();
 
$fiber->resume('after resuming');

Si vous voulez en savoir plus sur les fibres, ce qu’elles peuvent et ne peuvent pas faire, vous pouvez lire cet article .

#Amélioration des performances rp

Dmitry Stogov a ajouté quelques améliorations à opcache, il l’appelle « heritage cache ». Cette fonctionnalité permet de mettre en cache les liens entre les classes, tout comme les classes liées peuvent être préchargées à partir de PHP 7.4.

Dmitry rapporte entre 5% et 8% d’augmentation des performances grâce à ce changement, un petit détail sympa à surveiller dans PHP 8.1.

#Déballage du tableau avec des clés de chaîne rfc

Le déballage des tableaux était déjà autorisé dans PHP 7.4 , mais il ne fonctionnait qu’avec des touches numériques. La raison pour laquelle les clés de chaîne n’étaient pas prises en charge auparavant est qu’il n’y avait pas de consensus sur la façon de fusionner les doublons de tableau. La RFC résout clairement ce problème en suivant la sémantique dearray_merge :

$array1 = ["a" => 1];

$array2 = ["b" => 2];

$array = ["a" => 0, ...$array1, ...$array2];

var_dump($array); // ["a" => 1, "b" => 2]

#new dans les initialiseurs rfc

Cette RFC vous permet d’utiliser le newmot – clé dans les définitions de fonction comme paramètre par défaut, ainsi que dans les arguments d’attribut et à d’autres endroits.

class MyController {
    public function __construct(
        private Logger $logger = new NullLogger(),
    ) {}
}

Notez que ce RFC est toujours en cours de vote, mais il est déjà clair qu’il passera.

#Propriétés en lecture seule rfc

Les propriétés de classe peuvent être marquées en lecture seule, ce qui signifie qu’elles ne peuvent être écrites qu’une seule fois.

class PostData {
    public function __construct(
        public readonly string $title,
        public readonly DateTimeImmutable $date,
    ) {}
}

Essayer de modifier une propriété en lecture seule après son initialisation entraînera une erreur :

$post = new Post('Title', /* … */);

$post->title = 'Other';

Error: Cannot modify readonly property Post::$title

Si vous souhaitez en savoir plus sur les propriétés en lecture seule en profondeur, vous pouvez lire mon article de suivi .

Notez que ce RFC est toujours en cours de vote, mais il est déjà clair qu’il passera.

#Syntaxe appelable de première classe rfc

Vous pouvez maintenant faire une fermeture à partir d’un callable en appelant ce callable et en le passant ...comme argument :

function foo(int $a, int $b) { /* … */ }

$foo = foo(...);

$foo(a: 1, b: 2);

Notez que ce RFC est toujours en cours de vote, mais il est déjà clair qu’il passera.

#Types d’intersection purs rfc

Vous connaissez déjà les types d’union dans PHP 8.0 et les types d’intersection sont une fonctionnalité similaire. Là où les types d’union nécessitent que l’entrée soit l’un des types donnés, les types d’intersection nécessitent que l’entrée soit de tous les types spécifiés. Les types d’intersection sont particulièrement utiles lorsque vous travaillez avec de nombreuses interfaces :

function generateSlug(HasTitle&HasId $post) {
    return strtolower($post->getTitle()) . $post->getId();
}

Si vous aimez ce style de programmation, vous devrez créer une nouvelle interface Sluggableet l’implémenter dans $post, les types d’intersection se débarrassent de cette surcharge.

#Nouveau nevertyperfc

Le nevertype peut être utilisé pour indiquer qu’une fonction arrêtera réellement le déroulement du programme. Cela peut être fait en lançant une exception, en appelant exitou en d’autres fonctions similaires.

function dd(mixed $input): never
{
    // dump
    
    exit;
}

neverdiffère de voidce voidqui permet toujours au programme de continuer. Cela peut sembler une nouveauté, mais c’est en fait une fonctionnalité très utile pour les analyseurs statiques.

#Nouvelle array_is_listfonctionrfc

Vous avez probablement dû faire face à cela de temps en temps : déterminer si les clés d’un tableau sont dans l’ordre numérique, à partir de l’index 0. Tout comme json_encodedécide si un tableau doit être encodé en tant que tableau ou objet.

PHP 8.1 ajoute une fonction intégrée pour déterminer si un tableau est une liste avec cette sémantique ou non :

$list = ["a", "b", "c"];

array_is_list($list); // true

$notAList = [1 => "a", 2 => "b", 3 => "c"];

array_is_list($notAList); // false

$alsoNotAList = ["a" => "a", "b" => "b", "c" => "c"];

array_is_list($alsoNotAList); // false

#Constantes de classe finale rfc

Les constantes de classe en PHP peuvent être remplacées lors de l’héritage :

class Foo
{
    public const X = "foo";
}
 
class Bar extends Foo
{
    public const X = "bar";
}

Depuis PHP 8.1, vous pouvez marquer ces constantes comme finalafin d’éviter cela :

class Foo
{
    final public const X = "foo";
}
 
class Bar extends Foo
{
    public const X = "bar";
    Fatal error: Bar::X cannot override final constant Foo::X
}

#Nouvelle fsyncfonctionrfc

PHP 8.1 ajoute les fonctions fsyncet fdatasyncpour forcer la synchronisation des modifications 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.

$file = fopen("sample.txt", "w");

fwrite($file, "Some content");

if (fsync($file)) {
    echo "File has been successfully persisted to disk.";
}

fclose($file);

Étant donné que la synchronisation de disque est une opération de système de fichiers, la fsyncfonction ne fonctionnera que sur des flux de fichiers simples. Tenter de synchroniser des flux non-fichiers émettra un avertissement.

#Notation littérale d’entier octal explicite rfc

Vous pouvez maintenant utiliser 0oet 0Opour désigner les nombres octaux. La notation précédente en préfixant un nombre avec 0fonctionne toujours aussi.

016 === 0o16; // true
016 === 0O16; // true

#Changements marquants

Bien que PHP 8.1 soit une version mineure, il y aura quelques changements qui pourraient techniquement être un changement de rupture, ainsi que des dépréciations. Discutons-en un par un.

#Restreindre l’ $GLOBALSutilisationrfc

Un petit changement dans la façon dont $GLOBALSest utilisé aura un impact significatif sur les performances de toutes les opérations de la baie. Nikita fait un excellent travail en expliquant le problème et la solution dans le RFC . Le changement signifie que certains cas limites ne sont plus possibles avec $GLOBALS. ” Ce qui n’est plus supporté, ce sont les écritures dans $GLOBALS prises dans leur ensemble. Tout ce qui suit va générer une erreur de compilation ” :

$GLOBALS = [];
$GLOBALS += [];
$GLOBALS =& $x;
$x =& $GLOBALS;
unset($GLOBALS);

En plus de cela, le passage $GLOBALSpar référence générera une erreur d’exécution :

by_ref($GLOBALS); // Run-time error

Nikita a analysé les 2000 meilleurs packages sur Packagist et n’a trouvé que 23 cas qui seront affectés par ce changement. Nous pouvons conclure que l’impact de ce changement – techniquement irréversible – sera faible, c’est pourquoi les internes ont décidé de l’ajouter dans PHP 8.1. N’oubliez pas que la plupart d’entre nous gagneront à ce changement, étant donné l’impact positif sur les performances qu’il a partout dans notre code.

#Migrations de ressources vers des objets

Ces changements s’inscrivent dans la vision à long terme de convertir toutes les ressources en objets dédiés. Vous pouvez en savoir plus à ce sujet ici .

Fonctions Fileinfo avec des finfoobjets

Fonctions comme finfo_fileet finfo_openutilisées pour accepter et renvoyer des ressources. Depuis PHP 8.1, ils fonctionnent avec des finfoobjets.

Fonctions IMAP avec des IMAPConnectionobjets

Tout comme le changement fileinfo, IMAP fonctionne comme imap_bodyet imap_openne fonctionne plus avec les ressources

#Déprécier le passage de null à des arguments non nullables de fonctions internes rfc

Ce changement est simple : les fonctions internes acceptent actuellement les nullarguments non nullables, cette RFC désapprouve ce comportement. Par exemple, c’est actuellement possible :

str_contains("string", null);

En PHP 8.1, ces types d’erreurs lanceront un avertissement de dépréciation, en PHP 9, ils seront convertis en erreurs de type.

#Autovivification activée false rfc

Du RFC :

PHP permet nativement l’autovivification (création automatique de tableaux à partir de fausses valeurs). Cette fonctionnalité est très utile et utilisée dans de nombreux projets PHP, surtout si la variable n’est pas définie. Cependant, il y a une petite bizarrerie qui permet de créer un tableau à partir d’une valeur false et null.

Vous pouvez lire les détails sur la page RFC. En résumé, ce comportement est obsolète :

$array = false;

$array[] = 2;

Automatic conversion of false to array is deprecated

#Autres petits changements

Avec chaque version, il y a un tas de changements très mineurs dans la langue. Tous sont répertoriés dans le guide de MISE À JOUR sur GitHub et les petites dépréciations RFC , assurez-vous de le vérifier si vous voulez connaître chaque petit détail.

Voici un résumé des changements les plus importants :

• MYSQLI_STMT_ATTR_UPDATE_MAX_LENGTH n’a plus d’effet
• MYSQLI_STORE_RESULT_COPY_DATA n’a plus d’effet
• AOP::ATTR_STRINGIFY_FECHES fonctionne maintenant aussi avec les booléens
• Les entiers et les flottants dans les ensembles de résultats PDO MySQL et Sqlite seront renvoyés à l’aide de types PHP natifs au lieu de chaînes lors de l’utilisation d’instructions préparées émulées
• Les fonctions comme htmlspecialcharset htmlentitiesmaintenant s’échappent également 'par défaut vers '; UTF-8 malformé sera également remplacé par un caractère Unicode, au lieu d’aboutir à une chaîne vide
• Le hash, hash_fileet hash_initont un argument supplémentaire qui leur est ajouté appelé $options, il a une valeur par défaut de []donc cela n’affectera pas votre code
• Nouveau support pour MurmurHash3etxxHash

C’est tout pour l’instant, gardez à l’esprit que je mettrai régulièrement à jour ce post au cours de l’année. Êtes-vous enthousiasmé par PHP 8.1 ? Faites le moi savoir