Le PHP 8 est là ! La mise à jour majeure a été publiée le 26 novembre 2020 et nous apporte quelques changements fondamentaux ainsi que de nombreuses nouvelles fonctionnalités. Notre développeur Marten explique dans quel cas PHP 8 conduit réellement à de meilleures performances et si vous devez déjà mettre à jour votre version en tant qu'utilisateur de WordPress :in.

Introduction au PHP 8 

Le PHP 8 a été présenté pour la première fois à ses testeurs alpha le 18 juin 2020 et est gelé depuis juillet. Aucun nouvel ajout n'a donc été autorisé jusqu'à la sortie le 26 novembre. Une caractéristique unique de cette version est que nous sautons le PHP 7.5 et passons directement au PHP 8. Et ce saut est accompagné de nombreuses fonctionnalités. 

L'une des questions les plus fréquentes que se posent les utilisateurs de WordPress à propos de PHP 8 est probablement la suivante : PHP 8 va-t-il améliorer les performances de mon site web ?

La réponse à cette question est (comme c'est si souvent le cas) : "Cela dépend..."

Lorsque le PHP est passé de la version 5 à la version 7, les performances ont été considérablement améliorées. Avec PHP 8, cependant, vous ne verrez pas d'amélioration globale des performances à moins que votre application ne calcule beaucoup de fonctions mathématiques (voir notre section sur le compilateur JIT). Cela est principalement dû au fait que l'optimisation du code de PHP est déjà très bien établie.

Mais qui dit que la performance est limitée pour compiler le temps de toute façon ? Pour ma part, en tant que développeur, je mesurerais les performances de plusieurs façons, notamment les fonctionnalités dont je dispose pour écrire un code bien structuré. Et le PHP 8 est plein de nouvelles bonnes choses. Alors, commençons !

Mises à jour des fonctionnalités de PHP 8 

Le PHP 8 comporte huit nouvelles fonctionnalités majeures que j'aimerais vous présenter brièvement : 

1. Le compilateur JIT 
2. Attributs
3. Arguments nommés
4. Expressions de correspondance 
5. Expressions de jet
6. Type de retour statique 
7. Type d'Union 
8. Types mixtes 

Le compilateur JIT (juste à temps) (rfc)

Lorsque le code PHP est exécuté, il est généralement réalisé en compilant des instructions virtuelles qui sont exécutées sur une machine virtuelle. Le JIT changera cela en compilant le code en code machine x86 et en exécutant ensuite ce code directement sur l'unité centrale. Pour les applications qui reposent fortement sur des fonctions mathématiques, cela devrait se traduire par une augmentation des performances. Toutefois, cela n'est pas prévu pour les applications web moyennes (voir graphique). 

Pour un exemple des gains de performance qui peuvent être obtenus grâce au JIT, il est préférable de regarder la vidéo ci-dessous.

Fondamentalement, si vous utilisez PHP pour une tâche mathématique à forte intensité de main-d'œuvre, votre application fonctionnera plus facilement avec la nouvelle version. Mais si vous utilisez PHP comme la plupart des utilisateurs de WordPress , vous ne remarquerez pas de changement. J'explique ci-dessous ce que le PHP 8 signifie pour les propriétaires de sites web WordPress . 

Passons aux nouvelles fonctionnalités :

Attributs v2(rfc, rfc)

L'une des nouvelles fonctionnalités de PHP 8 (qui a suscité de nombreuses discussions au sein de la communauté PHP) sont les attributs - appelés "annotations" dans de nombreux autres langages. Les attributs remplacent la nécessité de stocker les métadonnées par des blocs de documents en PHP 8. C'est ce à quoi vous deviez recourir pour déclarer de manière structurée les métadonnées des classes, méthodes, fonctions et arguments. 

Comme vous pouvez l'imaginer, l'utilisation de commentaires de code pour appliquer les métadonnées n'était pas idéale, mais cela a fonctionné. Heureusement, nous n'aurons pas ce problème maintenant. 

Les attributs peuvent être définis à l'aide de la Syntax #[...] déclaré.

Voici quelques exemples tirés du RFC sur la façon dont les attributs peuvent être appliqués à différents types de données.

#[ExampleAttribute]
class Foo
{
    #[ExampleAttribute]
    public const FOO = 'foo';
 
    #[ExampleAttribute]
    public $x;
 
    #[ExampleAttribute]
    public function foo(#[ExampleAttribute] $bar) { }
}
 
$object = new #[ExampleAttribute] class () { };
 
#[ExampleAttribute]
function f1() { }
 
$f2 = #[ExampleAttribute] function () { };
 
$f3 = #[ExampleAttribute] fn () => 1;

A ce stade, il convient de noter que le RFC pour les attributs a subi plusieurs changements depuis sa conception initiale, ce qui montre les efforts et la réflexion qui ont été consacrés à cette mise à jour. 

Arguments nommés(rfc)

Lesarguments nommés vous donnent plus de souplesse pour appeler les fonctions. Jusqu'à présent, vous deviez appeler une fonction et passer chaque argument dans l'ordre spécifié par la fonction. 

// Using positional arguments:
array_fill(0, 100, 50);

Les arguments nommés vous permettent de définir un nom pour chaque paramètre. Et maintenant, ils peuvent être rappelés à l'ordre, comme décrit ci-dessous : 

// Using named arguments:
array_fill(start_index: 0, num: 100, value: 50);

Ils peuvent également être consultés comme suit :

array_fill(value: 50, num: 100, start_index: 0);

Un hybride des deux est également possible, permettant de combiner des paramètres nommés et des arguments de position, ce qui améliore la lisibilité du code : 

htmlspecialchars($string, double_encode: false);

Expressions de correspondance(rfc)

Match Expressions est destiné à résoudre certains problèmes de longue date dans la fonctionnalité de son prédécesseur, Switch. 

opérateur de comparaison

Switch utilise un opérateur relationnel de conversion de type (==), ce qui peut causer des problèmes. En revanche, Match utilise un opérateur de comparaison strict (===), indépendant des types_stricts.

valeur de retour

Les déclarations de commutation créent souvent une valeur qui est nécessaire plus tard dans le déroulement du programme. Il peut arriver que cette valeur ne soit pas définie dans l'instruction switch, ce qui peut ensuite entraîner des problèmes dans le script PHP. En outre, la syntaxe de la déclaration switch rend difficile la lecture des déclarations switch imbriquées.

switch (1) {
    case 0:
        $y = 'Foo';
        break;
    case 1:
        $y = 'Bar';
        break;
    case 2:
        $y = 'Baz';
        break;
}
 
echo $y;
//> Bar

La nouvelle expression de correspondance élimine ce problème en attribuant directement la valeur de retour pour chaque branche de correspondance(=>), ce qui est plus intuitif. 

echo match (1) {
    0 => 'Foo',
    1 => 'Bar',
    2 => 'Baz',
};
//> Bar

Fallthrough

Si une déclaration de commutation ne comporte pas de pause après chaque cas, elle passera au cas suivant même si le code est cassé. Il a été conçu pour permettre aux fonctions de commutation d'exécuter plusieurs blocs de code en séquence. Toutefois, cela a été une source d'erreurs fréquente. 

Match a mis en place une rupture implicite après chaque branche (=>). Il est désormais possible d'exécuter plusieurs conditions en plaçant des virgules entre chaque condition : 

match ($x) {
    1, 2 => {
        // Same for 1 and 2
    },
    3, 4 => {
        if ($x === 3) {
            // Only 3
        }
        // Same for 3 and 4
    },
}

Expressions de jet(rfc)

En PHP 8, la déclaration de lancer est devenue une expression. Cela signifie que le lancer peut maintenant techniquement rendre une valeur. Cela est utile dans le sens où le lancer peut maintenant être utilisé dans beaucoup plus d'endroits, comme les fonctions de flèches ou les opérateurs de coalescence. 

Fonctions des flèches : 

$callable = fn() => throw new Exception();

Opérateurs de coalescence : 

// $value is non-nullable.
$value = $nullableValue ?? throw new InvalidArgumentException();
 
// $value is truthy.
$value = $falsableValue ?: throw new InvalidArgumentException();

Opérateurs ternaires :

// $value is only set if the array is not empty.
$value = !empty($array)
    ? reset($array)
    : throw new InvalidArgumentException();

Type de retour statique(rfc)

Comme le dit ce RFC, Static Return Type permet de renvoyer le nom de classe spécial "static" d'une méthode : "Le nom de classe spécial statique en PHP se réfère à la classe d'une méthode qui a été réellement appelée, même si la méthode est héritée. C'est ce qu'on appelle la "liaison statique tardive" (LSB). Ce RFC propose de rendre le statique également utilisable comme type de retour (à côté des types self et parent déjà utilisables)".

Cependant, dans ce cas, Static ne peut pas être utilisé comme partie d'un paramètre. Le retour statique fera référence à la classe qui a été appelée. 

Types d'Union(rfc)

Types d'Union vous permettent de déclarer le type de valeur que vous attendez d'une entrée. Dans certaines langues, cela s'appelle un schéma. Cela se fait de manière syntaxique en utilisant  | (par exemple string|array|int) définis. Mais la magie ne s'arrête pas là, car vous pouvez aussi utiliser des classes définies comme :

class MyClass {

}

function myFunction(string|array|int|MyClass){

}

Les types d'Union sont déjà utilisés dans le PHP. Toutefois, ils sont mis en œuvre en utilisant la méthode des annotations phpdoc, comme indiqué ci-dessous. 

class Number {
    /**
     * @var int|float $number
     */
    private $number;
 
    /**
     * @param int|float $number
     */
    public function setNumber($number) {
        $this->number = $number;
    }
 
    /**
     * @return int|float
     */
    public function getNumber() {
        return $this->number;
    }
}

Pour un peu plus de contexte sur l'utilisation, consultez cet exemple du 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;
    }
}

Tout cela se résume au fait que vous pouvez utiliser plusieurs types d'entrée pour la même fonction au lieu d'un seul, ce qui permet un plus grand degré de réutilisation du code.

Types mixtes(rfc)

Dans les versions récentes de PHP, il était possible de déclarer le type de données d'entrée et de retour attendu. Cependant, PHP n'a pas toujours pris en charge les types, ce qui pose un problème. Dans certains cas, un type a été omis ou simplement oublié. MixedTypes tente maintenant de résoudre ce problème.

Afficher un mixed serait l'équivalent de array|bool|callable|int|float|null|object|resource|string

Voici un exemple tiré de la documentation du RFC sur la manière dont il est utilisé :

// Valid example
 
class A
{
    public function foo(int $value) {}
}
 
class B extends A
{
    // Parameter type was widened from int to mixed, this is allowed
    public function foo(mixed $value) {}
}

Caractéristiques supplémentaires du PHP 8

Rendre le tri stable(rfc)

La stabilité est ajoutée à toutes les fonctions qui relèvent de Sort (par exemple.

sort, rsort, usort, asort, arsort, uasort, ksort, krsort, uksort, array_multisort).

Je vous recommande de lire les documents RFC et de les comparer à votre application, car le passage de cette fonctionnalité du tri instable au tri stable pourrait avoir un impact négatif sur votre code.

Promotion de la propriété du constructeur(rfc)

Cette fonction devrait vous aider à accélérer votre processus de développement et à réduire les erreurs. Actuellement, la définition d'un objet de valeurs nécessite un ensemble de plaques chauffantes, comme indiqué ci-dessous dans la documentation RFC:

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;
    }
}

Dans cette méthode, les propriétés doivent être répétées trois fois. L'amélioration de cette situation est la formule courte ci-dessous : 

class Point {
    public function __construct(
        public float $x = 0.0,
        public float $y = 0.0,
        public float $z = 0.0,
    ) {}
}

Zero Safe Operator(rfc)

Il y a un nouvel opérateur dans ce quartier ! 

Anstelle des klassischen <code>!== null</code> haben wir nun das bekommen: <code>?-></code>. Es scheint zunächst merkwürdig, aber wenn man es unter dem Gesichtspunkt der Verkettung von „if-Statements“ betrachtet, dann wird die Anwendung ziemlich deutlich: 

$country =  null;
 
if ($session !== null) {
    $user = $session->user;
 
    if ($user !== null) {
        $address = $user->getAddress();
 
        if ($address !== null) {
            $country = $address->country;
        }
    }
}
 
// do something with $country

$country = $session?->user?->getAddress()?->country;
 
// do something with $country

str_contains(rfc)

Cette nouvelle fonction plutôt sympathique renvoie une valeur booléenne (vrai/faux) si une chaîne est trouvée dans une autre chaîne. Il faut deux arguments, la chaîne de caractères à rechercher et la chaîne de caractères à rechercher.

str_contains('php8', '8'); // true

str_contains('php8', 'wordpress'); // false

Pour des filtres de chaînes encore plus utiles, découvrez ces nouvelles fonctionnalités :

str_starts_with('haystack', 'hay'); // true
str_ends_with('haystack', 'stack'); // true

Ces deux méthodes donneront un résultat booléen et fonctionneront de la même manière que str_contains().

Cartes de la faiblesse(rfc)

En PHP, lorsque vous fixez une variable à la valeur d'un objet, cela crée généralement une référence à cet objet, mais pas un nouvel objet. 

Dans ce cas, vous pouvez donc avoir de nombreuses références à un objet, mais un seul objet. Le problème est le suivant : lorsque le moment est venu de supprimer cet objet, PHP compte le nombre de références de cet objet. Et s'il y en a plus d'un, PHP refusera de supprimer cet objet. 

Weak Maps résout ce problème en créant une référence "faible" à l'objet correspondant. Dès que l'objet est supprimé, toutes les variables avec la référence Weak Maps sur cet objet sont mises à zéro. 

Captures non capturées(rfc)

Un bloc d'essai est déjà assez impressionnant lorsqu'il s'agit de signaler des erreurs et il existe maintenant un moyen encore plus rapide de le mettre en œuvre. Et non, cela n'affectera pas vraiment la lisibilité. 

La méthode "old school" signifiait que vous deviez passer votre exception de capture à une variable comme celle-ci :

function catchMeWhenIFall(){
	try {
        throw new Exception('NOPE - GRAVITY');
    } catch (Exception $e) {
        return $e->getMessage();
    }

}

Mais maintenant, vous n'avez plus besoin de définir la variable à passer à votre bloc de capture.

try {
	throw new Exception('FOO!');
 catch  (){
	//Do some code here
 }

}

Autres documents de lecture du PHP 8

Si vous souhaitez en savoir plus sur la sortie de PHP 8 ou consulter les échantillons de code RFC, il vous suffit de jeter un coup d'œil à l'annonce officielle de la sortie. 

Êtes-vous prêt pour le PHP 8 ? 

Aucun développeur n'est fan des mises à jour avec de gros changements (on se souvient de WordPress 5.0 et Gutenberg), où il y a un risque que votre code se casse et des heures de travail ou une reconstruction complète vous attendent. Cependant, si votre code fonctionne bien avec PHP 7.4, vous ne devriez pas avoir de problèmes avec PHP 8 (plus d'informations sur PHP et WordPress dans le prochain chapitre). 

Toutefois, si vous utilisez une ancienne version de PHP, vous devez vérifier la liste des fonctionnalités obsolètes avant de procéder à la mise à jour. Voir la documentation "Annexes" de PHP pour une liste complète des fonctionnalités précédentes, des changements et des problèmes lors de la mise à jour d'une version de PHP à la suivante. 

Mettre à jour WordPress vers PHP 8 ? 

Cette citation tirée durapportYoast "WordPress and PHP 8 Compatibility Report" suggère déjà qu'en tant qu'utilisateur(trice) de WordPress, tu ne dois pas prendre à la légère la mise à jour vers PHP 8. La conclusion du rapport renforce cette hypothèse, car Omar Reiss écrit : "En examinant simplement un sous-ensemble de modifications de rupture dans PHP 8, nous pourrions déjà confirmer que cela risque de provoquer des ruptures majeures sur les sites dont l'origine de ces ruptures n'est pas claire. Souvent, l'erreur se produira à un endroit, mais sera causée par un plugin ou un thème à un autre endroit, rendant ces problèmes difficiles à déboguer".

Ces problèmes de compatibilité sont également la raison pour laquelle PHP 8 n'a pas été disponible immédiatement pour nos clients. En effet, surtout après des mises à jour majeures, il est toujours judicieux de laisser aux développeurs de plugins WordPress suffisamment de temps pour procéder à d'éventuelles adaptations et d'attendre pour le moment. Maintenant, tu peux facilement mettre à jour ton site Web vers PHP 8 ou PHP 8.1 via le Tableau de bord Raidboxes. Nous t'expliquons comment tester correctement une nouvelle version de PHP sur Raidboxes dans cet article du centre d'aide.

Notre conclusion sur PHP 8

Le PHP 8 est un grand pas en avant par rapport à ses prédécesseurs. Même si vous ne constaterez pas immédiatement une amélioration spectaculaire des performances (selon la façon dont vous utilisez PHP 8), vous devriez envisager la mise à jour - au moins après l'avoir testée, elle est stable et disponible auprès de votre hébergeur WordPress . La nouvelle version est une progression naturelle, et en la mettant en œuvre le plus tôt possible, vous poserez une base solide pour les améliorations futures, la croissance et l'amélioration des performances.