PHP 8.3 et 8.4 : toutes les nouveautés du PHP moderne en 2026

1. L'état de PHP en 2026

PHP est loin d'être mort. En 2026, le langage propulse environ 75 % des sites web dont le langage serveur est identifiable, selon W3Techs. WordPress, Drupal, Magento, Symfony, Laravel : l'écosystème PHP est vaste et continue de croître. Les versions 8.x ont profondément modernisé le langage, le rapprochant de la rigueur typée de langages comme TypeScript ou Kotlin.

Le cycle de release annuel de PHP (chaque version majeure sort en novembre) garantit une évolution régulière. PHP 8.3 est la version de référence en production, PHP 8.4 est en cours d'adoption, et PHP 8.5 est en développement actif. Pour comprendre en profondeur ce qui rend PHP si durable, lisez nos 10 raisons d'aimer PHP.

Calendrier des versions PHP

Version	Sortie	Support actif	Sécurité
PHP 8.1	Nov 2021	Terminé	Déc 2025
PHP 8.2	Déc 2022	Déc 2025	Déc 2026
PHP 8.3	Nov 2023	Nov 2026	Nov 2027
PHP 8.4	Nov 2025	Nov 2028	Nov 2029

2. Le système de types moderne

Le typage PHP a connu une évolution spectaculaire depuis PHP 7.0. En 2026, PHP offre un système de types qui n'a rien à envier aux langages statiquement typés.

Union types (PHP 8.0)

Les union types permettent de déclarer qu'un paramètre ou un retour peut être de plusieurs types :

function processInput(string|int $input): string|false
{
    if (is_int($input)) {
        return (string) $input;
    }
    return strlen($input) > 0 ? $input : false;
}

Intersection types (PHP 8.1)

Les intersection types exigent qu'une valeur implémente plusieurs interfaces simultanément :

function processCollection(Countable&Iterator $items): void
{
    echo "Nombre d'éléments : " . count($items);
    foreach ($items as $item) {
        // traitement
    }
}

DNF types (PHP 8.2)

Les types DNF (Disjunctive Normal Form) combinent union et intersection types, permettant des déclarations de types très précises :

function processData((Countable&Iterator)|null $data): void
{
    if ($data === null) {
        return;
    }
    // $data est à la fois Countable ET Iterator
}

Typed class constants (PHP 8.3)

PHP 8.3 permet enfin de typer les constantes de classe, éliminant une source de bugs dans les hiérarchies d'héritage :

interface HasVersion
{
    const string VERSION = '1.0';
}

class App implements HasVersion
{
    const string VERSION = '2.0'; // OK : même type
    // const int VERSION = 2;     // Erreur fatale : type incompatible
}

Le match expression (PHP 8.0)

Le match est une alternative stricte à switch qui utilise la comparaison stricte (===), retourne une valeur et ne nécessite pas de break :

$statusText = match($statusCode) {
    200 => 'OK',
    301 => 'Moved Permanently',
    404 => 'Not Found',
    500 => 'Internal Server Error',
    default => 'Unknown Status',
};

3. Les enums : un ajout fondamental

Les enums, introduits en PHP 8.1, sont l'une des fonctionnalités les plus attendues de l'histoire du langage. Ils permettent de définir un ensemble fini de valeurs nommées avec un type fort, remplaçant les constantes de classe désorganisées.

Enums purs

enum Suit
{
    case Hearts;
    case Diamonds;
    case Clubs;
    case Spades;
}

function getColor(Suit $suit): string
{
    return match($suit) {
        Suit::Hearts, Suit::Diamonds => 'red',
        Suit::Clubs, Suit::Spades => 'black',
    };
}

Backed enums

Les backed enums associent chaque cas à une valeur scalaire, facilitant la sérialisation et le stockage en base de données :

enum Status: string
{
    case Draft = 'draft';
    case Published = 'published';
    case Archived = 'archived';

    public function label(): string
    {
        return match($this) {
            self::Draft => 'Brouillon',
            self::Published => 'Publié',
            self::Archived => 'Archivé',
        };
    }
}

// Utilisation
$status = Status::from('published');    // Status::Published
$status = Status::tryFrom('invalid');   // null (pas d'exception)
echo Status::Published->value;          // "published"
echo Status::Published->label();        // "Publié"

Les enums s'intègrent parfaitement avec Doctrine (Symfony) et Eloquent (Laravel). Doctrine supporte nativement les backed enums comme type de colonne depuis la version 2.14. Cela illustre la manière dont le PHP moderne favorise une bonne réflexion sur la POO.

4. Readonly properties et classes

Le mot-clé readonly, introduit en PHP 8.1 pour les propriétés et étendu aux classes en PHP 8.2, renforce l'immutabilité du code.

Readonly properties (PHP 8.1)

class User
{
    public function __construct(
        public readonly string $email,
        public readonly string $name,
        public readonly \DateTimeImmutable $createdAt,
    ) {}
}

$user = new User('[email protected]', 'Antoine', new \DateTimeImmutable());
echo $user->email;       // OK
// $user->email = 'x';   // Erreur : propriété readonly

Readonly classes (PHP 8.2)

Le modificateur readonly sur une classe rend toutes ses propriétés readonly implicitement. C'est la manière la plus concise de créer des objets valeur immutables :

readonly class Money
{
    public function __construct(
        public float $amount,
        public string $currency,
    ) {}

    public function add(Money $other): self
    {
        if ($this->currency !== $other->currency) {
            throw new \InvalidArgumentException('Currencies must match');
        }
        return new self($this->amount + $other->amount, $this->currency);
    }
}

5. Fibers et programmation asynchrone

Les fibers (PHP 8.1) sont des coroutines légères qui permettent de suspendre et reprendre l'exécution d'une fonction. Elles constituent la base technique de l'asynchrone en PHP, utilisée par des bibliothèques comme ReactPHP et Amp.

$fiber = new Fiber(function (): void {
    $value = Fiber::suspend('hello');
    echo "Fiber reçoit : " . $value;
});

$result = $fiber->start();          // "hello"
echo "Valeur suspendue : $result";
$fiber->resume('world');            // Affiche "Fiber reçoit : world"

En pratique, les développeurs applicatifs n'utilisent pas directement les fibers. Elles servent principalement aux auteurs de frameworks et de bibliothèques d'I/O asynchrones. L'écosystème ReactPHP, par exemple, les exploite pour proposer des clients HTTP non-bloquants, des serveurs WebSocket et des drivers de base de données asynchrones, tout en conservant une API synchrone familiale pour le développeur final.

6. PHP 8.4 : property hooks et au-delà

PHP 8.4, sorti en novembre 2025, introduit des fonctionnalités qui changent profondément la manière d'écrire du PHP. Les deux plus marquantes sont les property hooks et la visibilité asymétrique.

Property hooks

Les property hooks remplacent les getters et setters traditionnels par une syntaxe intégrée à la déclaration de propriété :

class User
{
    public string $fullName {
        get => $this->firstName . ' ' . $this->lastName;
    }

    public string $email {
        set(string $value) {
            $this->email = strtolower(trim($value));
        }
    }

    public function __construct(
        private string $firstName,
        private string $lastName,
        public string $email,
    ) {}
}

Visibilité asymétrique

Il est désormais possible de définir des visibilités différentes pour la lecture et l'écriture d'une propriété :

class BankAccount
{
    public private(set) float $balance;

    public function __construct(float $initialBalance)
    {
        $this->balance = $initialBalance;
    }

    public function deposit(float $amount): void
    {
        $this->balance += $amount; // OK : écriture interne
    }
}

$account = new BankAccount(1000);
echo $account->balance;          // OK : lecture publique
// $account->balance = 500;      // Erreur : écriture privée

Lazy objects

PHP 8.4 intègre nativement les lazy objects dans le moteur Reflection, permettant de différer l'initialisation d'un objet jusqu'à son premier accès. C'est une fonctionnalité que Doctrine utilisait via des proxy générés. Désormais, le support natif simplifie l'implémentation et améliore les performances des ORM et des conteneurs d'injection de dépendances.

7. Performance : JIT et OPcache

PHP 8 intègre un compilateur JIT (Just-In-Time) qui compile le bytecode PHP en code machine natif à l'exécution. L'impact sur les performances dépend du type d'application.

Quand le JIT fait la différence

Le JIT brille sur les charges de travail CPU-intensives : traitement d'images avec GD/Imagick, calculs mathématiques, génération de PDF, compression de données, et applications de machine learning en PHP. Les gains peuvent atteindre 2 à 3x sur ces types de tâches.

Pour les applications web classiques (Laravel, Symfony, WordPress), le JIT n'apporte qu'un gain marginal (5-10 %) car le goulot d'étranglement se situe au niveau des I/O (base de données, réseau). OPcache reste le premier levier de performance à activer en production.

Configuration optimale en production

; php.ini - Configuration OPcache optimale
opcache.enable=1
opcache.memory_consumption=256
opcache.interned_strings_buffer=16
opcache.max_accelerated_files=20000
opcache.validate_timestamps=0
opcache.save_comments=1

; JIT (optionnel, pour charges CPU)
opcache.jit_buffer_size=100M
opcache.jit=1255

; Preloading (Symfony/Laravel)
opcache.preload=/path/to/preload.php
opcache.preload_user=www-data

Preloading

Le preloading (PHP 7.4+) charge les classes en mémoire au démarrage de PHP-FPM, éliminant le coût de chargement à chaque requête. Symfony génère automatiquement un fichier de preloading optimisé qui inclut les classes les plus utilisées. Le gain est mesurable : réduction de 10 à 15 % du temps de réponse sur les applications Symfony en production. Pour une comparaison complète de l'écosystème serveur, consultez notre comparaison entre PHP et Node.js.

8. Stratégies de migration

Migrer vers PHP 8.x est un investissement qui paie rapidement en termes de sécurité, de performance et de qualité de code. Voici une méthodologie éprouvée.

Étape 1 : Analyse statique

Utilisez PHPStan ou Psalm au niveau maximal pour détecter les incompatibilités avant même de changer la version de PHP. Ces outils identifient les fonctions dépréciées, les changements de signatures, les types incompatibles et les comportements modifiés.

Étape 2 : Automatisation avec Rector

Rector est un outil de refactoring automatique qui transforme le code PHP selon des règles prédéfinies. Il peut automatiquement ajouter les déclarations de types, remplacer les switch par des match, convertir les constructeurs en promotion de propriétés, et appliquer des dizaines d'autres transformations :

# Installer Rector
composer require rector/rector --dev

# Configurer pour PHP 8.3
# rector.php
return RectorConfig::configure()
    ->withPhpSets(php83: true)
    ->withPaths([__DIR__ . '/src'])
    ->withTypeCoverageLevel(10);

# Exécuter
vendor/bin/rector process

Étape 3 : Changements critiques à surveiller

• Fonctions internes : les fonctions PHP internes lèvent désormais des TypeError et ValueError au lieu de retourner false ou d'émettre des warnings
• Concaténation : la précédence de l'opérateur . a changé par rapport aux opérateurs arithmétiques
• Paramètres nommés : les noms de paramètres font désormais partie du contrat d'API
• Nullsafe operator (?->) : remplace les vérifications null imbriquées
• Propriétés dynamiques : dépréciées en PHP 8.2, interdites en PHP 9.0

Étape 4 : Tests et déploiement progressif

Exécutez votre suite de tests complète avec la nouvelle version de PHP. Déployez d'abord sur un environnement de staging, puis en production avec un déploiement canary (un pourcentage du trafic routé vers la nouvelle version). Surveillez les logs d'erreurs et les métriques de performance pendant 48 heures avant de basculer entièrement.