Tutoriel Vidéo PHP Les nouveautés de PHP 7.4

Télécharger la vidéo

La version 7.4 de PHP est sorti il y a un peu moins d’un mois et je vous propose de faire un tour d’horizon des nouvelles fonctionnalités apportées par cette version.

Short arrow function

Une nouvelle syntaxe a été ajoutée pour écrire une fonction courte qui ne dispose que d’une instruction. Cette syntaxe va simplifier l’écriture de callback simple.

// PHP 7.3
$items = array_filter($items, function ($i) { return $i % 2 === 0});

// PHP 7.4
$items = array_filter($items, fn ($i) => $i % 2 === 0);

Il est aussi intéressant de noter que ces fonctions ne nécessite pas l'utilisation du use() pour l'utilisation de variables externes :

$age = 18;
$adults = array_filter($users, ($u) => $u->age >= $age);

Typage des propriétés

Cette version étend encore le système de typage et il est possible maintenant de spécifier le type des propriétés d’une classe

class User {

    public int $age;

    public Profile $profile;

}

Ce typage apporte aussi un changement de comportement. Vous ne pouvez pas accéder à une propriété qui n’a pas été initialisée.

class User {

    public ?int $age;

}

$user = new User();
$user->age;  // Erreur

Covariance du retour et contravariance des arguments

Ce changement apporte plus de flexibilité au moment de l’héritage avec la possibilité de définir des types différents de la classe parente (tout en respectant le contrat initial)

  • Le type de retour peut être plus précis que celui définie dans la méthode parente
  • Le type des arguments peut être plus large que celui définit dans la méthode parente
class A {}
class B extends A {}

class Parent {
    public function demo(B $b): A {
        // ...
    }
}

// Le paramètre est plus large (class parente)
// Le type de retour est plus précis (class enfant)
class Enfant extends {
    public function demo(A $a): B {

    }
}

Spread operator pour les tableaux

Le spread operator peut maintenant être utilisé au niveau des tableaux ce qui va permettre de simplifier la fusion de listes (cela ne fonctionne que sur les tableaux avec des clefs numériques).

$a = [1, 2];
$b = [3, 4];
$c = [0, ...$a, ...$b, 5]; // [0, 1, 2, 3, 4, 5]

Null coalescing assignment

Cet opérateur permet d’assigner une valeur par défaut si une variable n’est pas défini :

// PHP 7.3
$a = $a ?? 'default';

// PHP 7.4
$a ??= 'default';

Séparateur numérique littéral

Il est maintenant possible d'utiliser un caractère de soulignement pour mieux identifier les nombres visuellement.

$a = 100_000;
$b = 0.000_002;

Références faibles : WeakReference

Cet ajout permet de créer une référence vers un objet sans empécher sa destruction.

$a = new A();
$container->set('A', $a);
unset($a); // $container contient une référence à A et l'objet ne peux donc être supprimé.

La création d'une référence faible se fait au travers de la classe WeakReference.

$a = new A();
$ref = WeakReference::create($a);
$ref->get(); // A
unset($a);
$ref->get(); // NULL

Cet ajout est intéressant car il offre plus d'outils pour optimiser les performances d'une application et la libération de la mémoire.

Dépréciations

Certaines instructions sont maintenant dépréciées :

$a = 1 ? 2 : 3 ? 4 : 5; // DEPRECIE, Il est nécessaire maintenant de mettre des parenthèse pour identiifer la priorité des opérations
$a = (1 ? 2 : 3) ? 4 : 5; // OK

$a = "3" . 1 + 2; // DEPRECIE, La précédence risque de changer sur PHP 8, il faut donc utiliser des parenthèses
$a = "3" . (1 + 2); // OK

Preloading de l'OPcache

Cette option va être particulièrement intéréssante pour les frameworks car elle permet de précharger l'opcache dès le démarrage du serveur. Ce qui permet de rendre l'ensemble des classes préchargées disponible au niveau des requêtes.
Pour l'instant cela se gère au niveau de la configuration de PHP à travers l'option opcache.preload qui permet de spécifier le chemin d'un fichier PHP qui va précharger les classes. Il serait donc possible d'imaginer dans le futur que des frameworks comme Symfony ou Laravel offre un fichier de préchargement en plus du framework afin d'accélérer les performances. En revanche, l'approche adoptée (un seul fichier PHP), peut être problématique pour des serveurs faisant tourner plusieurs versions des mêmes librairies. Il faudra donc attendre l'adoption de ce préchargement pour voir de quoi il en retourne.