PHP 8.3 est sorti le 23 novembre 2023. Retenez surtout où en est son cycle de vie : le support actif s'est arrêté le 31 décembre 2025 et la branche ne reçoit plus que des correctifs de sécurité, jusqu'au 31 décembre 2027. Pour un nouveau projet, visez PHP 8.4 ou 8.5.

🚀 Améliorations de performance

JIT (Just-In-Time) : rien de neuf en 8.3

Le JIT n'a pas bougé en PHP 8.3 : il existe depuis PHP 8.0, et c'est PHP 8.4 qui l'a réécrit sur le framework IR, où il arrive d'ailleurs désactivé par défaut.

Optimisations mémoire

Réduction de l'empreinte mémoire
Gestion plus efficace des objets
Collecte de déchets améliorée

🛡️ Classes readonly

Les classes readonly datent de PHP 8.2 et les propriétés readonly de PHP 8.1 ; PHP 8.3 se contente de les autoriser sur les classes anonymes et de permettre leur réinitialisation au clonage. Elles permettent de créer des objets immutables de manière simple et élégante.

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

// Utilisation
$user = new User(
    name: 'John Doe',
    email: '[email protected]',
    createdAt: new DateTimeImmutable()
);

// Impossible de modifier après création
// $user->name = 'Jane'; // Erreur fatale

Avantages des classes readonly

Immutabilité : Les objets ne peuvent pas être modifiés après création
Thread-safety : Sécurité dans les environnements multi-threads
Clarté du code : Intention claire de l'immutabilité
Performance : Optimisations possibles grâce à l'immutabilité

📊 Constantes de classe typées

PHP 8.3 améliore le système de types avec les constantes de classe typées ; la covariance complète des types de retour, elle, existe depuis PHP 7.4.

class Configuration
{
    const string ENVIRONMENT = 'prod';
    const int MAX_RETRIES = 3;
}

// Avant PHP 8.3, le type d'une constante de classe ne pouvait pas être déclaré

🔧 Nouveaux types de données

Type `json_validate()`

Validation native des chaînes JSON sans décodage complet.

if (json_validate($jsonString)) {
    $data = json_decode($jsonString);
    // Traitement sécurisé
}

Type `mb_str_pad()`

Padding de chaînes multi-octets avec support Unicode.

$text = mb_str_pad('Hello', 10, ' ', STR_PAD_RIGHT);
// Résultat : "Hello     "

🎯 Côté syntaxe

Expression `match` : inchangée en 8.3 (elle date de PHP 8.0)

$result = match ($status) {
    'active' => 'Utilisateur actif',
    'inactive' => 'Utilisateur inactif',
    'pending' => 'En attente de validation',
    default => 'Statut inconnu'
};

🔒 Améliorations de sécurité

Validation des types plus stricte

Vérifications de types plus rigoureuses
Meilleure détection des erreurs à la compilation
Réduction des erreurs runtime

Hachage : xxHash est rapide, pas cryptographique

// Hachage très rapide mais non cryptographique, disponible depuis PHP 8.1
$hash = hash('xxh3', $data);

📦 Fonctions utiles à connaître

`array_is_list()` (PHP 8.1)

Vérifie si un tableau est une liste séquentielle.

$list = [1, 2, 3];
$assoc = ['a' => 1, 'b' => 2];

var_dump(array_is_list($list)); // true
var_dump(array_is_list($assoc)); // false

`str_starts_with()` et `str_ends_with()` (PHP 8.0)

Vérifications de préfixes et suffixes : si vous êtes déjà en PHP 8, vous les avez.

$url = 'https://example.com';

if (str_starts_with($url, 'https://')) {
    echo 'URL sécurisée';
}

if (str_ends_with($url, '.com')) {
    echo 'Domaine .com';
}

🎨 Améliorations des messages d'erreur

Le format lisible que vous connaissez date en réalité de PHP 8.0 :

// Avant PHP 8.0
// Fatal error: Uncaught TypeError: Argument 1 passed to function() must be of the type string, null given

// Depuis PHP 8.0
// Fatal error: Uncaught TypeError: function(): Argument #1 ($param) must be of type string, null given, called in /path/to/file.php on line 10

Côté erreurs, l'apport réel de la 8.3 est ailleurs : l'interface objet de Date/Time lève des exceptions dédiées, regroupées sous la hiérarchie DateException, là où elle produisait des warnings ou des exceptions génériques.

🔧 Compatibilité et migration

Changements breaking

Suppression de certaines fonctions dépréciées
Comportements modifiés pour certaines fonctions
Nouvelles exigences de types

Guide de migration

Vérifiez la compatibilité avec php -l
Testez votre code avec PHP 8.3
Mettez à jour les dépendances
Adaptez les types si nécessaire

🚀 Performance : ce que disent les mesures

Aucun gain de performance chiffré n'est annoncé par l'équipe PHP pour la 8.3
Au lancement, Phoronix ne relève aucun écart notable de performance face à PHP 8.2
Les mesures Tideways de novembre 2025 confirment : entre 8.2, 8.3, 8.4 et 8.5, la performance bouge peu
Votre gain se joue sur OPcache, le JIT et votre code, pas sur le numéro de version

🎯 Bonnes pratiques avec PHP 8.3

Utilisez les classes readonly

readonly class Configuration
{
    public function __construct(
        public string $environment,
        public array $settings,
        public DateTimeImmutable $lastModified
    ) {}
}

Profitez des nouveaux types

class UserService
{
    public function createUser(
        string $name,
        string $email,
        ?string $phone = null
    ): User {
        // Validation avec json_validate si nécessaire
        return new User($name, $email, $phone);
    }
}

Optimisez avec les nouvelles fonctions

class StringUtils
{
    public static function isValidEmail(string $email): bool
    {
        return str_ends_with($email, '.com') || 
               str_ends_with($email, '.fr');
    }
}

🔮 Conclusion

PHP 8.3 représente une évolution majeure du langage avec :

Typage plus fin : constantes de classe typées
Sécurité renforcée : Types plus stricts et validation
Productivité accrue : Nouvelles syntaxes et fonctions
Maintenabilité : Code plus clair et moins d'erreurs

Pour migrer vers PHP 8.3, consultez le guide de migration officiel et testez vos applications dans un environnement de développement.

PHP 8.3 continue d'évoluer vers un langage plus moderne, plus performant et plus sûr. L'avenir de PHP s'annonce prometteur !

PHP 8.3 : Les nouvelles fonctionnalités qui changent tout