PHP 8 - Nouvelles fonctionnalités, améliorations et problèmes potentiels liés à WordPress

Marten Gülink Dernière mise à jour le 11.01.2021
10 Min.
Mise à jour majeure de php 8
Dernière mise à jour le 11.01.2021


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 !

Les principales nouveauté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). 

PHP 8 - Nouvelles fonctionnalités, améliorations et problèmes potentiels liés à WordPress
Source

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.

YouTube

En chargeant la vidéo, vous acceptez la politique de confidentialité de YouTube.
En savoir plus

Afficher la vidéo

PGlmcmFtZSBzcmM9Imh0dHBzOi8vd3d3LnlvdXR1YmUtbm9jb29raWUuY29tL2VtYmVkL2RXSDY1cG1uc3JJIiBhbGxvdz0iYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGNsaXBib2FyZC13cml0ZTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZSIgYWxsb3dmdWxsc2NyZWVuPSIiIHdpZHRoPSI1NjAiIGhlaWdodD0iMzE1IiBmcmFtZWJvcmRlcj0iMCI+PC9pZnJhbWU+

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 manière 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 l'indique cette RFC, le Static Return Type permet le retour du nom de classe spéciale "static" d'une méthode : "Le nom de classe spéciale statique en PHP fait référence à la classe sur laquelle une méthode a été effectivement appelée, même si la méthode est héritée. C'est ce qu'on appelle la "reliure statique tardive" (LSB). Ce RFC propose de rendre statique également utilisable comme type de retour (à côté des types self et parent déjà utilisables)".

La statique ne peut toutefois pas être utilisée comme un paramètre dans ce cas. 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 ! 

Au lieu du classique <code>!== nul</code>, nous avons maintenant ceci : <code>?-></code>. Cela semble étrange au premier abord, mais si vous l'envisagez du point de vue de l'enchaînement des "déclarations si", la demande devient tout à fait claire : 

$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. Une fois que l'objet est supprimé, toutes les variables avec la référence Weak Maps à 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. 

Devriez-vous mettre à jour votre WordPress en PHP 8 ? 

Pour les bases de code bien tapées ou les bases de code qui sont restées à jour avec les dernières versions de PHP, il n'y a pas de gros problème [pour migrer vers PHP 8]. La réalité, cependant, est que WordPress n'est pas une telle base de code.

Omar Reiss, au revoir

Cette citation de la Yoast "WordPress and PHP 8 Compatibility Report" suggère déjà que vous, en tant qu'utilisateur de WordPress :in, ne devriez pas traiter la mise à jour de PHP 8 à la légère. La conclusion du rapport renforce cette hypothèse, comme l'écrit Omar Reiss : "En étudiant simplement un sous-ensemble de modifications de rupture dans le PHP 8, nous pourrions déjà confirmer que cela est susceptible de provoquer des ruptures majeures sur des sites dont l'origine de ces ruptures n'est pas claire. Souvent, l'erreur se produit à un endroit, mais elle est causée par un plugin ou un theme à un autre endroit, ce qui rend ces problèmes difficiles à déboguer".

Ces problèmes de compatibilité expliquent également pourquoi PHP 8 n'est pas immédiatement disponible dans le tableau de bord RAIDBOXES pour nos clients. Surtout après des mises à jour importantes, il est toujours bon de laisser aux développeurs de Plugin suffisamment de temps pour faire les ajustements nécessaires et attendre le moment venu. Dès que nous serons sûrs qu'il n'y a pas de problèmes avec une installation standard de WordPress et que PHP 8 fonctionne de manière stable et performante sur notre système, nous mettrons bien sûr PHP 8 à disposition.

Si vous avez déjà accès à PHP 8 et que vous souhaitez tester la nouvelle version avec votre site WordPress , vous devez - comme avant chaque mise à jour - créer d'abord une sauvegarde. La façon de tester correctement une nouvelle version de PHP sur RAIDBOXES peut être lue dans cet article du Helpcenter (ici en utilisant PHP 7.2 comme exemple).

Notre conclusion

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.

D'autres questions sur le PHP 8 ?

J'espère avoir pu vous présenter les nouvelles fonctionnalités de PHP 8 avec cet article. Vous avez d'autres questions sur le sujet ? N'hésitez pas à utiliser la fonction de commentaire. Vous voulez plus de conseils sur WordPress , la conception de sites web et bien plus encore ? Alors suivez-nous sur Twitter, Facebook ou via notre newsletter.

En tant que développeur web sur RAIDBOXES , Marten travaille sans cesse sur de nouvelles fonctionnalités pour nos clients. Sur "wp unboxed", il marque également des points grâce à ses connaissances en matière de développement web, WordPress et notre tableau de bord. Et pendant son temps libre, il aime aussi s'occuper de l'auto-hébergement et des dernières tendances sur Internet.

Articles connexes

Commentaires sur cet article

Laisse un commentaire

Ton adresse électronique ne sera pas publiée. Les champs obligatoires sont marqués d'un *.