--- title: 'PHP 8.3: Typed Constants, #[Override], json_validate & Upgrade Notes | DevSense' description: 'Guide PHP 8.3 après la version 8.2 : attribut #[Override], constantes de classe typées, ajustements sur le clonage readonly, json_validate, str_increment/str_decrement, sécurité de range().' faq: - { question: "À quoi sert l'attribut #[Override] dans PHP 8.3 ?", answer: "L'attribut #[Override] indique qu'une méthode doit surcharger une méthode parente ou une déclaration d'interface. Si la méthode parente est renommée ou supprimée, PHP génère une erreur fatale de compilation." } - { question: 'Comment fonctionnent las constantes de classe typées dans PHP 8.3 ?', answer: "Les constantes de classe, d'interface, de trait et d'enum peuvent désormais déclarer des types spécifiques (comme string, int, bool, float ou array). Les valeurs assignées doivent strictement correspondre à ce type lors de la compilation." } - { question: "Quel est l'avantage de json_validate() dans PHP 8.3 ?", answer: 'json_validate() vérifie si une chaîne est un JSON valide sans la décoder, ce qui évite la consommation de CPU et de mémoire de json_decode() pour les simples étapes de validation.' } - { question: 'Comment change le clonage des propriétés readonly dans PHP 8.3 ?', answer: 'Les propriétés readonly peuvent désormais être réinitialisées dans la méthode `__clone()`, ce qui facilite le clonage en profondeur (deep cloning) et la modification de structures immuables.' } published: '2026-05-31' --- # PHP 8.3 : Fonctionnalités majeures Une version de peaufinage pour les équipes utilisant PHP 8.2.x : des invariants plus forts (`#[Override]`, constantes typées), une meilleure ergonomie sur le JSON et les chaînes de caractères (`json_validate`, `str_increment`/`str_decrement`), et une série de petits changements d'exécution qui se manifestent sous forte charge ou dans des cas particuliers. ## Table des matières * [`#[\Override]` — détecter les surcharges manquantes à la compilation](#override-attribute) * [Constantes de classe typées](#typed-constants) * [Readonly : classes anonymes & clonage](#readonly-tweaks) * [Améliorations de confort du langage (QoL)](#language-qol) * [Nouvelles fonctions à adopter (`json_validate`, `str_*`, DOM, Random)](#new-functions) * [Changements non rétrocompatibles (notes de migration)](#backward-incompatible) * [Dépréciations (incrément/décrément de chaînes, `get_class()`, configuration INI d'assert)](#deprecations) * [Autres changements & opérations (gc_status, flux de données, points clés)](#other-changes) * [Erreurs courantes](#common-mistakes) * [Quiz d'auto-évaluation](#self-test-quiz) --- PHP 8.3 se concentre sur le renforcement de la sécurité des contrats et l'optimisation de la consommation de ressources. En introduisant les constantes de classe typées et l'attribut `#[\Override]`, PHP sécurise la refactorisation et prévient les dérives silencieuses d'API. Pour les développeurs gérant des API à fort trafic, la nouvelle fonction `json_validate()` offre un moyen léger de vérifier les données reçues sans gaspiller de mémoire à les analyser. Cependant, ces améliorations s'accompagnent de règles de validation plus strictes dans la bibliothèque standard (en particulier pour `range()` et les fonctions de sockets), ainsi que de la dépréciation des anciens comportements d'incrémentation de chaînes de caractères. Voici comment mettre à niveau vos applications en toute transparence. ## `#[\Override]` — détecter les surcharges manquantes à la compilation Marquez les méthodes qui sont censées surcharger une méthode parente ou d'interface. Si le nom est incorrect ou si le parent supprime la méthode, **PHP échoue immédiatement** au lieu d'introduire silencieusement une nouvelle méthode. > [!NOTE] > **Le saviez-vous ?** > L'attribut `#[Override]` est totalement ignoré par le moteur d'exécution au moment de l'exécution ! Il s'agit purement d'un contrôle à la compilation conçu pour intercepter les erreurs de refactorisation et les divergences d'implémentation d'interfaces avant même que votre code ne s'exécute. ```php // app/Services/Loggers/FileLogger.php interface Logger { public function log(string $message): void; } final class FileLogger implements Logger { #[\Override] public function log(string $message): void { // ... } } ``` Utilisez-le en particulier dans les bases de code volumineuses où les refactorisations modifient les noms des méthodes d'interface. --- ## Constantes de classe typées Les constantes sur les **classes, interfaces, traits et enums** peuvent déclarer des types, alignant ainsi les constantes sur le reste du système de types. ```php // app/Config/AppConfig.php interface Config { public const string APP_NAME = 'MyApp'; } ``` Cela réduit les bogues liés à des types de constantes erronés qui ne se manifestaient auparavant qu'au moment de leur utilisation. --- ## Readonly : classes anonymes & clonage * **Les classes anonymes** peuvent être déclarées `readonly`. * **Les propriétés readonly** peuvent être **réinitialisées lors d'un `clone`** (à l'intérieur de la méthode `__clone()`), ce qui rend le clonage d'objets immuables beaucoup moins contraignant qu'avec les structures limitées de PHP 8.2. --- ## Améliorations de confort du langage (QoL) * **Accès dynamique aux constantes de classe** : `SomeClass::{$name}` pour lire des constantes dynamiquement à l'exécution. * **Initialisations de variables statiques** : elles peuvent utiliser des expressions arbitraires (et non plus uniquement des constantes). * **Mot-clé `final` sur les méthodes de traits** lors de l'importation d'une méthode de trait. * **Fermetures créées à partir de méthodes magiques** : elles peuvent recevoir des **arguments nommés** lors de leur appel. * **`php.ini`** : syntaxe de valeur par défaut/de secours pour une configuration plus propre. --- ## Nouvelles fonctions à adopter ### `json_validate()` Validez du JSON **sans le décoder** sous forme de valeurs PHP—idéal pour les API, les files d'attente et les vérifications rapides avant un appel coûteux à `json_decode()`. > [!NOTE] > **Le saviez-vous ?** > L'utilisation de `json_validate()` consomme beaucoup moins de mémoire que `json_decode()` car elle ne construit aucun tableau ou objet PHP en mémoire ! Elle scanne simplement la syntaxe de la chaîne, ce qui la rend parfaite pour valider de gros volumes de données avant leur traitement. ```php // app/Http/Middleware/JsonValidateMiddleware.php if (!json_validate($payload)) { throw new InvalidArgumentException('JSON invalide'); } $data = json_decode($payload, true, flags: JSON_THROW_ON_ERROR); ``` ### `str_increment()` / `str_decrement()` Remplaçants recommandés pour les opérations historiques `++`/`--` sur les chaînes de caractères (voir les dépréciations). À utiliser pour les compteurs alphanumériques. ```php // app/Services/CounterService.php $next = str_increment('a9'); // comportement prévisible sans utiliser ++ sur les chaînes $prev = str_decrement($next); ``` ### DOM, Intl, Random, POSIX, etc. PHP 8.3 ajoute de nombreuses méthodes **DOM** (ex. `insertAdjacentElement`, `getRootNode`, `replaceChildren`), des utilitaires de calendrier **Intl**, des méthodes d'échantillonnage **Random** sur `Randomizer` (`getFloat`, `nextFloat`, …), et des fonctions **POSIX** (`sysconf`/`pathconf`/`eaccess`)—utiles pour les scripts système et les outils CLI. --- ## Changements non rétrocompatibles (notes de migration) ### Pile d'exécution / temporisateurs / fibers * **Récursion profonde** : les appels récursifs proches de la limite de la pile peuvent désormais lever une `Error` en cas de dépassement de `zend.max_allowed_stack_size` ; les fibers utilisent `fiber.stack_size` de la même manière. * **Zend Max Execution Timers** : activés par défaut pour les builds ZTS sous Linux—surveillez vos scripts CLI à exécution longue. ### Processus * **`proc_get_status()`** sous POSIX renvoie les valeurs correctes lors d'appels **répétés** ; les résultats peuvent être **mis en cache** (vérifiez la clé `"cached"`). Appeler **`proc_close()`** après `proc_get_status()` produit désormais les codes de sortie réels (et non plus `-1`). ### Tableaux & traits * **Visibilité des constantes de classe** : la variance est désormais appliquée lorsque les constantes sont héritées d'**interfaces**—les codes qui s'appuyaient sur une visibilité plus souple peuvent nécessiter des corrections. * **Tableau vide + premier index négatif** : la clé implicite suivante sera `n+1` (et non plus `0`). * **Traits avec propriétés statiques** : les propriétés statiques héritées du parent sont désormais **redéclarées** pour chaque classe utilisant le trait (zones de stockage séparées)—ce qui peut affecter certains comportements de variables statiques. ### Bibliothèque standard (impact élevé) * **`range()`** : validation plus stricte (`TypeError`/`ValueError` pour les entrées incorrectes), alertes supplémentaires pour les limites incohérentes, comportement différent pour les plages de caractères si les limites ressemblent à des nombres—**re-testez** tout code générant des plages à partir d'entrées utilisateur. * **`number_format()`** : une valeur négative pour `$decimals` arrondit désormais **avant** la virgule (ignoré auparavant). * **`file()`** : les combinaisons d'options invalides sont rejetées (par exemple, `FILE_APPEND` était accepté silencieusement auparavant). ### Date / DOM / FFI / Opcache * **Date** : hiérarchies de classes **`DateError`/`DateException`** plus riches à la place des avertissements/exceptions génériques—mettez à jour vos blocs `catch`. * **DOM** : comportement aligné sur les spécifications pour les nœuds sans parents ; corrections de `createAttributeNS()` ; les nouveaux membres peuvent entrer en **conflit** avec des sous-classes utilisateur—veillez à la compatibilité des signatures. * **FFI** : les fonctions C retournant `void` renvoient désormais **`null`**, et non plus un objet factice `FFI\CData:void`. * **Opcache** : `opcache.consistency_checks` a été **supprimé** (le fonctionnement était défectueux avec le JIT et le cache d'héritage). ### WeakMap * **Clés auto-référencées** dans un `WeakMap` : elles peuvent être collectées par le ramasse-miettes (garbage collector) dans les cycles où la visibilité n'est assurée que par l'itération—vérifiez vos architectures de cache complexes. --- ## Dépréciations ### Opérateurs `++` / `--` sur les chaînes de caractères L'incrément/décrément sur des chaînes **vides ou non numériques** est déprécié. Privilégiez **`str_increment()`** / **`str_decrement()`** dans vos nouveaux développements. ### `get_class()` / `get_parent_class()` sans arguments Appeler ces fonctions **sans arguments** est déprécié—passez explicitement un objet ou un nom de classe. ### Assertions * **`assert_options()`** et ses **constantes** associées sont dépréciées. * Les **directives INI `assert.*`** sont dépréciées. --- ## Autres changements & opérations * **`gc_status()`** rapporte des statistiques temporelles plus précises (durée de collecte/destruction/libération)—utile pour optimiser les scripts manipulant de gros volumes de mémoire. * **Flux de données** : `fread()` sur les sockets peut retourner des données plus rapidement si des données tamponnées existent. * **`open_basedir`** : à l'exécution, `ini_set` rejette les chemins contenant `..` même s'ils sont précédés de `./`. --- ## ⚠️ Erreurs courantes Voici quelques pièges courants lors de l'utilisation des fonctionnalités de PHP 8.3 : ### 1. Utiliser l'opérateur d'incrémentation (++) sur les chaînes de caractères En PHP 8.3, utiliser l'opérateur `++` ou `--` sur des chaînes de caractères non numériques déclenche un avertissement de dépréciation. ```php // app/Services/Counter.php // MAUVAIS : Déclenche un avertissement de dépréciation en PHP 8.3 $code = 'a9'; $code++; // BON : Utilisez la nouvelle fonction d'aide str_increment $code = str_increment('a9'); // 'b0' ``` ### 2. Incompatibilité des types de constantes dans les sous-classes Si une classe parente définit une constante typée, les classes enfants qui surchargent cette constante doivent respecter exactement le type défini. ```php // app/Config/DatabaseConfig.php class ParentConfig { public const string DRIVER = 'mysql'; } // MAUVAIS : Fatal Error: ChildConfig::DRIVER type (int) is not compatible with ParentConfig::DRIVER type (string) class ChildConfig extends ParentConfig { public const int DRIVER = 123; } ``` ### 3. Appeler `get_class()` sans arguments Appeler `get_class()` sans lui passer d'argument pour récupérer le nom de la classe courante est déprécié en PHP 8.3. ```php // app/Services/LogService.php // MAUVAIS : Déclenche un avertissement de dépréciation en PHP 8.3 class LogService { public function log(): void { echo "Logging from " . get_class(); } } // BON : Utilisez self::class ou passez explicitement $this class LogService { public function log(): void { echo "Logging from " . self::class; // OU : echo "Logging from " . get_class($this); } } ``` --- ## Quiz d'auto-évaluation Testez votre compréhension des nouveautés de PHP 8.3. ### Question 1 : Que se passe-t-il si vous définissez une constante de classe typée et que vous lui attribuez une valeur d'un type différent (ex : `public const int NAME = 'MyApp';`) en PHP 8.3 ? * A) Cela déclenche un avertissement de dépréciation, mais le script s'exécute avec succès. * B) PHP convertit automatiquement la chaîne en l'entier `0`. * C) Cela lève une `Fatal Error` au moment de la compilation.
Afficher la réponse **Réponse : C** Dans PHP 8.3, les constantes de classe typées sont rigoureusement vérifiées à la compilation. Assigner une valeur incompatible à una constante typée produit une erreur fatale.
### Question 2 : Pourquoi devriez-vous utiliser `json_validate()` plutôt que `json_decode()` si vous souhaitez simplement vérifier si une chaîne contient du JSON valide ? * A) `json_validate()` est plus rapide et utilise beaucoup moins de mémoire car elle ne construit pas les structures de tableaux/objets PHP. * B) `json_validate()` prend en charge des formats de JSON que `json_decode()` ne sait pas analyser. * C) `json_decode()` sera déprécié dans les futures versions de PHP.
Afficher la réponse **Réponse : A** `json_validate()` analyse uniquement la syntaxe de la chaîne JSON sans allouer de mémoire pour les structures décodées, ce qui la rend beaucoup plus performante pour les étapes de simple validation.
--- ## Résumé PHP 8.3 renforce la sécurité des contrats de code et optimise la consommation des ressources. Grâce à l'introduction des constantes de classe typées et de l'attribut `#[Override]`, le code devient plus robuste et les erreurs de refactorisation sont évitées.