Les propriétés typées

C’est la grande nouveauté. Depuis PHP 7.0, on pouvait typer les paramètres de fonctions et les valeurs de retour. Mais les propriétés de classe ? Toujours non typées :

class User {
    public int $id;
    public string $name;
    public ?DateTimeInterface $deletedAt;
}

7.4 change ça. Les propriétés typées font respecter les types à l’affectation, pas seulement au niveau des sites d’appel. Les classes deviennent auto-documentées d’une façon que les docblocks n’ont jamais vraiment réussi à faire, et le moteur attrape les erreurs de type avant qu’elles ne se propagent dans la moitié de la stack.

Une subtilité : les propriétés typées sont uninitialized par défaut (pas null). Accéder à une propriété non initialisée lève une Error. C’est un piège classique : ?string n’implique pas un défaut de null. Il faut encore un = null explicite pour ça.

Les arrow functions

Les closures en PHP ont toujours nécessité d’importer explicitement les variables de la portée extérieure avec use :

$multiplier = 3;
$fn = fn($x) => $x * $multiplier; // pas besoin de use()

Les arrow functions capturent automatiquement la portée englobante. Expression unique, retour implicite, pas de boilerplate. Elles ne remplacent pas les closures complètes pour la logique complexe, mais pour les callbacks courts, elles éliminent une catégorie de bruit qui s’accumulait depuis des années.

Le préchargement opcache

Pour les setups PHP-FPM à longue durée de vie, le préchargement permet à un script de charger et compiler des fichiers PHP en mémoire opcache au démarrage du serveur. Ces fichiers sont disponibles pour toutes les requêtes sans overhead de compilation.

Le gain varie selon l’application. Sur les grands frameworks où les mêmes fichiers sont chargés à chaque requête, c’est réel. Sur les petites applications, négligeable. Vaut la peine de benchmarker avant d’ajouter la complexité de configuration.

Les petites choses qui s’accumulent

Les fonctionnalités mentionnées en passant méritent plus qu’une ligne. L’opérateur d’affectation null-coalescente ??= résout un pattern suffisamment agaçant à écrire à chaque fois, mais jamais assez pour se donner la peine de l’abstraire :

$config['timeout'] ??= 30;
// équivalent à : $config['timeout'] = $config['timeout'] ?? 30;

L’opérateur spread dans les littéraux de tableau fait ce qu’on attend de la version pour les appels de fonctions — dépacker un itérable dans un littéral de tableau :

$defaults = ['color' => 'blue', 'size' => 'M'];
$options = ['size' => 'L', ...$defaults, 'weight' => 1.2];
// ['size' => 'M', 'color' => 'blue', 'weight' => 1.2]

Note : les clés string n’étaient pas supportées dans 7.4 pour le dépaquet de tableau. Ça viendra plus tard.

Les types de retour covariants et les types de paramètres contravariants comblent un vide qui rendait certains patterns d’héritage inutilement maladroits. Une classe enfant peut maintenant affiner son type de retour vers un sous-type de celui du parent, sans erreur fatale :

class Producer {
    public function get(): Iterator {}
}
class ChildProducer extends Producer {
    public function get(): ArrayIterator {} // ArrayIterator implémente Iterator
}

Lire des nombres à 3h du matin

Le séparateur de littéraux numériques est une de ces fonctionnalités dont on ne sait pas qu’on la voulait jusqu’à la première fois qu’on écrit une grande constante et qu’on perd immédiatement le sens de l’ordre de grandeur :

$earthMass    = 5_972_168_000_000_000_000_000_000; // kg
$lightSpeed   = 299_792_458;                        // m/s
$planck       = 6.626_070_15e-34;                  // J·s
$hexMask      = 0xFF_EC_D5_08;
$binaryFlags  = 0b0001_1111_0010_0000;

L’underscore est purement syntaxique. Le moteur le supprime avant de parser la valeur. On peut le mettre n’importe où entre les chiffres, bien que la convention suive le groupement naturel du système numérique utilisé.

Référencer sans posséder

WeakReference permet de tenir une référence à un objet sans empêcher le ramasse-miettes de le détruire. Le cas d’usage : les caches et registres — on veut savoir qu’un objet est vivant, mais on ne veut pas être la raison qu’il reste vivant :

$object = new HeavyObject();
$ref = WeakReference::create($object);

var_dump($ref->get()); // object(HeavyObject)

unset($object);

var_dump($ref->get()); // NULL — le GC l'a collecté

Avant 7.4, il y avait WeakRef via une extension, et certains frameworks faisaient des tours de passe-passe avec SplObjectStorage qui ne se comportaient pas tout à fait pareil. La classe native est juste directe.

La sérialisation sans surprise

La sérialisation personnalisée d’objets avant 7.4 passait par l’interface Serializable : implémenter serialize() et unserialize(), retourner une string, reconstruire depuis elle. Le problème est que serialize() déclenchait __sleep(), unserialize() déclenchait __wakeup(), et l’interaction entre ces hooks était fragile, surtout dans les hiérarchies d’héritage.

7.4 introduit __serialize() et __unserialize(), qui travaillent avec des tableaux plutôt que des strings et n’interagissent pas avec les anciens hooks :

class Session {
    private string $token;
    private \DateTime $createdAt;

    public function __serialize(): array {
        return ['token' => $this->token, 'created' => $this->createdAt->getTimestamp()];
    }

    public function __unserialize(array $data): void {
        $this->token = $data['token'];
        $this->createdAt = (new \DateTime())->setTimestamp($data['created']);
    }
}

Quand les nouvelles et anciennes méthodes coexistent sur la même classe, __serialize() gagne. L’ancienne interface Serializable est dépréciée dans 8.1.

Ce que la bibliothèque standard a discrètement reçu

mb_str_split() fait ce que str_split() fait mais correctement pour les strings multibyte. Le manque était franchement embarrassant pour un langage utilisé dans autant de locales que PHP :

mb_str_split('héllo', 1); // ['h', 'é', 'l', 'l', 'o']
str_split('héllo', 1);    // ['h', 'Ã', '©', 'l', 'l', 'o'] — cassé

strip_tags() accepte maintenant un tableau de tags autorisés, ce qui est plus propre que le format string qu’il fallait passer auparavant :

strip_tags($html, ['p', 'br', 'strong']); // était : '<p><br><strong>'

proc_open() accepte maintenant un tableau de commandes, contournant complètement l’interprétation par le shell. Même idée que subprocess de Python avec shell=False. À retenir quand on passe des arguments fournis par l’utilisateur à un processus externe.

Le chapitre FFI

L’extension Foreign Function Interface a atterri dans 7.4 après avoir passé du temps dans une branche feature. Elle permet à PHP d’appeler des fonctions C natives en chargeant une bibliothèque partagée et en déclarant les signatures :

$ffi = FFI::cdef("int strlen(const char *s);", "libc.so.6");
var_dump($ffi->strlen("hello")); // int(5)

Les applications pratiques sont étroites mais réelles : appeler des API de plateforme sans binding PHP, wrapper du code C critique pour les performances sans écrire une extension complète, ou juste jouer avec des bibliothèques natives directement. Ce n’est pas un remplacement des extensions propres en production, mais ça supprime la barrière “écrire une extension C” pour l’exploration.

Ce qui a été déprécié

Quelques choses qui auraient dû être nettoyées depuis longtemps ont finalement reçu le traitement dépréciation dans 7.4.

Les ternaires imbriqués sans parenthèses ont toujours été ambigus. PHP les évaluait de gauche à droite alors que pratiquement tous les autres langages avec un ternaire évaluent de droite à gauche :

// Était ambigu, maintenant déprécié :
$a ? $b : $c ? $d : $e;

// Rendre explicite :
($a ? $b : $c) ? $d : $e;

L’accès par offset avec accolades pour les strings et tableaux — $str{0} au lieu de $str[0] — est déprécié et supprimé dans 8.0. C’était toujours un alias, jamais une fonctionnalité distincte.

implode() avec l’ordre d’arguments inversé (tableau en premier, colle en second) est déprécié. La fonction a accepté les deux ordres depuis le début, ce qui était une erreur. L’ordre correct est implode(string $separator, array $array).

Ce qui arrive ensuite

7.4 est la dernière version 7.x. Les dépréciations sont principalement du déblayage pour les suppressions dans 8.0. Le backlog de RFCs pour 8.0 est substantiel : JIT, attributs, arguments nommés, expressions match. 7.4 est un bon endroit où atterrir en attendant que tout ça arrive.

Le chiffre phare : 2x plus rapide que PHP 5.6. Ce n’est pas un benchmark cherry-pick — c’est la médiane sur des applications réelles. Le Zend Engine a été réécrit pour utiliser une nouvelle représentation interne des valeurs, ce qui réduit significativement l’utilisation mémoire et diminue les allocations. Sur un projet, le temps de réponse moyen a chuté de 40% sans aucune modification du code. On met à jour, et ça va plus vite.

Mais les performances ne sont pas la partie la plus intéressante.

Les types, enfin

PHP a eu les type hints pour les objets depuis la 5.0, pour les tableaux depuis la 5.1. En 7.0, on peut enfin déclarer des types scalaires pour les paramètres de fonctions et les valeurs de retour :

function add(int $a, int $b): int {
    return $a + $b;
}

En mode strict (declare(strict_types=1)), passer un float à cette fonction lève une TypeError. En mode coercitif par défaut, PHP convertit la valeur. Cette distinction compte : le mode strict est par fichier, on peut donc l’adopter progressivement sans tout casser d’un coup.

Les déclarations de type de retour constituent l’autre moitié. Placer l’intention dans la signature plutôt que dans un docblock signifie que c’est le moteur qui l’applique, pas un code reviewer à moitié endormi.

L’opérateur null coalescent

?? est petit mais utilisé en permanence :

$username = $_GET['user'] ?? 'guest';

Ça remplace isset($_GET['user']) ? $_GET['user'] : 'guest'. Il se chaîne aussi : $a ?? $b ?? $c. Après des années de bruit avec isset(), ça seul valait la mise à jour.

La partie qui casse

La refonte de la gestion des erreurs est le vrai risque lors de la migration. Beaucoup d’erreurs fatales sont maintenant des exceptions Error, attrapables mais différentes des Exception. Le code qui comptait sur les erreurs fatales pour stopper l’exécution silencieusement a maintenant besoin d’une gestion explicite. La suppression d’erreurs avec @ fonctionne aussi différemment par endroits.

Lire le guide de migration avant de toucher une appli en production. Le gain est réel, mais le fossé entre 5.6 et 7.0 est le plus large que PHP ait jamais eu.

L’opérateur vaisseau spatial

<=> est un opérateur de comparaison combiné qui retourne -1, 0 ou 1. Il est surtout là pour le tri :

usort($users, function ($a, $b) {
    return $a->age <=> $b->age;
});

Avant ça, un comparateur de tri personnalisé était un petit exercice de mémoire arithmétique. $a - $b fonctionne pour les entiers mais plante silencieusement pour les flottants. <=> fait ce qu’il faut pour chaque type comparable.

Les classes anonymes

On peut maintenant instancier une classe définie en ligne, sur le moment, sans lui donner de nom :

$logger = new class($config) implements LoggerInterface {
    public function __construct(private array $config) {}

    public function log(string $message): void {
        file_put_contents($this->config['path'], $message . PHP_EOL, FILE_APPEND);
    }
};

Le cas d’usage canonique, ce sont les doublures de test et les implémentations d’interface ponctuelles qui ne méritent pas un fichier. Ça supprime une vraie friction : le fossé entre “j’ai besoin d’un objet” et “je dois créer un fichier de classe pour un truc de 10 lignes”.

Aléatoire cryptographiquement sûr

Les rand() et mt_rand() de PHP 5 n’ont jamais été conçus pour la sécurité. La 7.0 ajoute deux fonctions qui le sont :

$token = bin2hex(random_bytes(32)); // token hexadécimal de 64 caractères
$pin   = random_int(100000, 999999);

random_bytes() puise dans le CSPRNG du système d’exploitation. random_int() enveloppe ça pour les entiers. Ces fonctions remplacent tous les schémas de génération de tokens maison qui faisaient ça mal en silence, ce qui représente la majorité d’entre eux.

Les déclarations use groupées

Avant 7.0, importer cinq éléments depuis le même namespace nécessitait cinq instructions use. Maintenant :

use App\Model\{User, Order, Product};
use function App\Helpers\{formatDate, slugify};
use const App\Config\{MAX_RETRIES, TIMEOUT};

Petite amélioration ergonomique, mais qui réduit le bruit visuel en haut des fichiers avec des hiérarchies de namespaces profondes.

Les générateurs ont grandi

Les générateurs en 5.5 étaient intéressants mais incomplets. La 7.0 ajoute deux choses. Premièrement, un générateur peut maintenant avoir une valeur de retour, accessible après la fin de l’itération :

function process(): Generator {
    yield 'step 1';
    yield 'step 2';
    return 'done';
}

$gen = process();
foreach ($gen as $step) { /* ... */ }
echo $gen->getReturn(); // "done"

Deuxièmement, yield from délègue à un autre générateur ou itérable, en transmettant transparemment les valeurs et valeurs de retour :

function inner(): Generator {
    yield 1;
    yield 2;
    return 'inner done';
}

function outer(): Generator {
    $result = yield from inner();
    echo $result; // "inner done"
    yield 3;
}

Ça rend la composition de générateurs pratique sans avoir à câbler manuellement les valeurs entre eux.

Closure::call()

Une façon plus directe de lier une closure à un objet et de l’appeler immédiatement :

class Counter {
    private int $count = 0;
}

$increment = function (int $by): void {
    $this->count += $by;
};

$increment->call(new Counter(), 5);

bindTo() existait avant mais nécessitait deux étapes. call() les fusionne et est plus rapide à l’exécution car il évite la création d’une closure intermédiaire.

Syntaxe d’échappement Unicode dans les chaînes

On peut maintenant intégrer des caractères Unicode directement dans les chaînes entre guillemets doubles ou les heredocs via un point de code :

echo "\u{1F418}"; // 🐘
echo "\u{00E9}";  // é

C’est mieux que de copier-coller des caractères depuis une table Unicode dans les fichiers sources, ce que les gens faisaient vraiment.

Un unserialize() plus sûr

unserialize() a une longue histoire d’être un vecteur d’attaques par injection d’objets. La 7.0 ajoute une option allowed_classes :

$data = unserialize($input, ['allowed_classes' => false]);
$data = unserialize($input, ['allowed_classes' => [User::class, Order::class]]);

Passer false empêche toute instanciation d’objet pendant la désérialisation. C’est le comportement par défaut à adopter quand on désérialise des données non fiables.

:1234: Division entière

intdiv() est une division entière explicite sans intermédiaire flottant :

$pages = intdiv(count($items), $perPage); // int, pas besoin de cast

Oui, on pourrait caster le résultat d’une division. intdiv() rend l’intention claire et évite les cas limites de précision flottante que le cast introduit pour les grands nombres.

Les constantes en tableaux

Avant 7.0, define() n’acceptait que les valeurs scalaires. Les tableaux fonctionnaient avec const au niveau de la classe ou du namespace mais pas avec define(). Maintenant si :

define('HTTP_METHODS', ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']);

Utile pour la configuration qui doit être une constante mais qui vit en dehors d’une classe.

Des assertions avec des dents

assert() a reçu une vraie refonte. En PHP 5, les assertions étaient un eval de chaînes à l’exécution. Maintenant elles peuvent lever des exceptions et être complètement supprimées en production avec zéro overhead :

// Dans php.ini ou au bootstrap :
// assert.active = 1 (dev), 0 (prod)
// assert.exception = 1

assert($user->isVerified(), new \LogicException('Unverified user reached checkout'));

Quand assert.active = 0, l’expression n’est jamais évaluée. Quand c’est activé, une assertion qui échoue lève directement l’exception fournie. C’est enfin un outil qu’on peut utiliser sans honte.

La refonte de session_start()

session_start() accepte maintenant un tableau d’options qui surchargent les directives php.ini pour cet appel :

session_start([
    'cookie_lifetime' => 86400,
    'cookie_secure'   => true,
    'cookie_httponly'  => true,
    'cookie_samesite' => 'Lax',
]);

Avant ça, on définissait soit les options globalement dans php.ini, soit on appelait ini_set() avant session_start(). Aucune des deux n’était top quand on avait besoin de configurations de session différentes dans différentes parties d’une appli.