PHP 8.0 : la révolution qui a tout changé

PHP 8.5 est là. Et si vous traînez encore avec du code PHP , accrochez-vous : vous avez cinq ans de révolutions à rattraper. Cette série de billets décortique toutes les fonctionnalités majeures qui ont transformé PHP en langage moderne : des arguments nommés au JIT en passant par les enums et les propriétés readonly.

Le langage a enfin grandi, et il était temps

Quand PHP 8.0 est sorti en novembre 2020, ce n'était pas juste une énième mise à jour incrémentale avec des corrections de bugs et quelques améliorations mineures. C'était un changement sismique qui a fondamentalement transformé la manière dont les développeurs écrivent du code PHP. Cette version a marqué l'évolution la plus importante du langage depuis plus d'une décennie, introduisant des fonctionnalités qui ont rendu PHP non seulement plus rapide, mais véritablement moderne. Si vous pensiez encore que PHP était ce langage de script brouillon des années 2000, il est temps de vous réveiller. PHP 8.0 est une toute autre bête.

Le compilateur JIT

La fonctionnalité phare de PHP 8.0 était sans aucun doute le compilateur JIT (Just-In-Time). Pendant des années, PHP s'est appuyé sur le moteur Zend pour compiler le code à l'exécution, mais le JIT va beaucoup plus loin en compilant les portions de code les plus sollicitées directement en code machine. Est-ce que ça veut dire que tous les sites WordPress sont soudainement devenus ultra-rapides ? Pas vraiment. Le JIT brille dans des scénarios spécifiques — tâches de calcul intensif, traitement d'images, algorithmes d'apprentissage automatique, c’est-à-dire là où les opérations liées au CPU dominent. Pour les applications web typiques qui passent la majorité de leur temps à attendre des bases de données et des API, les améliorations sont modestes. Mais pour ces cas d'usage spécifiques ? Les gains de performance sont tout simplement spectaculaires. On parle d'accélérations de 2 à 3 fois pour les calculs mathématiques et les opérations algorithmiques. PHP est soudainement devenu viable pour des cas d'usage pour lesquels il n'avait jamais été envisagé auparavant.

Arguments nommés

Vous vous souvenez de ces moments où vous deviez parcourir la documentation pour comprendre quel paramètre allait où dans une fonction avec huit arguments ? Ou pire, passer une série de valeurs null juste pour atteindre le paramètre que vous vouliez vraiment définir ? Les arguments nommés ont résolu ça élégamment :

// Avant
createUser('John', 'Doe', null, null, true, false, 'admin');

// PHP 8.0
createUser(
    firstName: 'John',
    lastName: 'Doe',
    isActive: true,
    role: 'admin'
);

Vous pouvez maintenant ignorer complètement les paramètres optionnels et spécifier uniquement ce dont vous avez besoin. L'ordre n'a plus d'importance. C'est lisible, maintenable et franchement, c'est comme ça que les appels de fonction auraient toujours dû fonctionner.

Attributs

Pendant des années, nous nous sommes appuyés sur les DocBlocks, ces blocs de commentaires au-dessus des classes et méthodes pour ajouter des métadonnées. Le problème ? Ce sont des commentaires. Ils ne font pas partie de la syntaxe du langage, ce qui signifie pas d'analyse native, pas de support IDE digne de ce nom, et tout un écosystème de parseurs bancals essayant de donner du sens à du texte structuré dans des commentaires. PHP 8.0 a introduit les Attributs, apportant un support d'annotations de premier ordre directement dans le langage :

// Avant
/**
 * @Route("/api/users", methods=["GET"])
 * @Cache(ttl=3600)
 */
class UserController {
    // ...
}

// PHP 8.0
#[Route("/api/users", methods: ["GET"])]
#[Cache(ttl: 3600)]
class UserController {
    // ...
}

Les Attributs sont analysés par PHP lui-même, validés au moment de la compilation, et entièrement supportés par les IDE. Des frameworks comme Symfony et Laravel les ont déjà largement adoptés, rendant les configurations de routage, validation et injection de dépendances plus propres et plus puissantes.

Promotion de propriétés de constructeur

Si vous avez écrit du PHP orienté objet, vous avez écrit ce pattern environ dix mille fois :

class User {
    private string $name;
    private string $email;
    private int $age;

    public function __construct(string $name, string $email, int $age) {
        $this->name = $name;
        $this->email = $email;
        $this->age = $age;
    }
}

C'est répétitif. C'est fastidieux. C'est du boilerplate qui n'ajoute aucune valeur. La promotion de propriétés de constructeur condense tout ça en une déclaration unique et élégante :

class User {
    public function __construct(
        private string $name,
        private string $email,
        private int $age
    ) {}
}

Même fonctionnalité. Un tiers du code. Les propriétés sont déclarées, typées et assignées au même endroit. C'est le genre d'amélioration qualité de vie qui semble mineure jusqu'à ce que vous réalisiez que vous avez écrit des centaines de lignes de code inutiles pendant des années.

Expression match

L'instruction switch a toujours été un peu dangereuse en PHP. Elle utilise une comparaison faible, nécessite des instructions break explicites (le fall-through est le comportement par défaut !), et ne retourne pas de valeurs directement. La nouvelle expression match corrige tout cela :

// Avant avec switch
switch ($statusCode) {
    case 200:
    case 201:
        $message = 'Succès';
        break;
    case 404:
        $message = 'Non trouvé';
        break;
    default:
        $message = 'Inconnu';
}

// Avec match
$message = match ($statusCode) {
    200, 201 => 'Succès',
    404 => 'Non trouvé',
    default => 'Inconnu',
};

Match utilise une comparaison stricte (===), ne fait pas de fall-through, et retourne directement une valeur. C'est une expression, pas une instruction, ce qui signifie que vous pouvez l'utiliser partout où vous utiliseriez une valeur. C'est plus propre, plus sûr et plus fonctionnel.

Opérateur Nullsafe

Les vérifications de null. Elles sont partout dans le code du monde réel. Et quand vous devez accéder à des propriétés ou méthodes imbriquées, elles se transforment en conditionnelles en pyramide :

// La méthode paranoïaque
$country = null;
if ($session !== null) {
    $user = $session->getUser();
    if ($user !== null) {
        $address = $user->getAddress();
        if ($address !== null) {
            $country = $address->getCountry();
        }
    }
}

// PHP 8.0 : Opérateur Nullsafe
$country = $session?->getUser()?->getAddress()?->getCountry();

L'opérateur ?-> court-circuite toute la chaîne si n'importe quelle étape retourne null. C'est élégant, lisible, et ça élimine toute une classe de patterns de programmation défensive qui encombraient les bases de code pendant des années.

Types d'union

PHP 7 a introduit les indications de type scalaire, mais vous ne pouviez spécifier qu'un seul type par paramètre ou valeur de retour. Si une fonction pouvait légitimement retourner différents types, vous étiez coincé avec de la documentation mixte dans les commentaires ou accepter mixed en perdant toute sécurité de typage. Les types d'union vous permettent de déclarer explicitement plusieurs types valides :

class ApiResponse {
    private int|float $value;

    public function getData(): array|object {
        // Peut retourner soit un array soit un object
}

	public function findUser(int|string $identifier): User|null {
    		// Accepte int ou string, retourne User ou null
	}
}

Cela apporte une véritable flexibilité sans sacrifier les avantages de la vérification de type. Votre IDE sait ce qui est valide. Les outils d'analyse statique peuvent vérifier la justesse. Et le runtime fait respecter vos contrats.

Le mot de la fin

PHP 8.0 n'était pas juste une mise à jour, c’était une déclaration. Après des années d'améliorations incrémentales, le langage a enfin fait un bond en avant audacieux, empruntant les meilleures idées des langages modernes tout en restant fidèle à ses racines pragmatiques. Le compilateur JIT a ouvert de nouvelles frontières de performance. Les arguments nommés et la promotion de propriétés de constructeur ont réduit le boilerplate. Les Attributs ont apporté un support natif de métadonnées. Les expressions match et l'opérateur nullsafe ont rendu le code plus propre et plus sûr. Les types d'union ont renforcé le système de types sans sacrifier la flexibilité. PHP est-il soudainement parfait ? Bien sûr que non. Mais PHP 8.0 représente quelque chose d'important : un langage mature qui continue d'évoluer, de s'améliorer, et qui reste pertinent dans le paysage du développement de 2025. Si vous n'avez pas encore exploré PHP 8.0, vous passez à côté de l'une des évolutions de langage les plus significatives de ces dernières années. Le PHP moderne pourrait bien vous surprendre.