--- title: 'PHP 7.1 from 7.0: Nullables, void, Symmetric Destructuring & Migration | DevSense' description: 'Guide de mise à niveau PHP 7.1 : types nullables, retours void, visibilité des constantes de classe, déstructuration symétrique de tableaux, pseudo-type iterable, multi-catch et décalages de chaînes négatifs.' faq: - { question: "Qu'est-ce que les types nullables en PHP 7.1 ?", answer: "Les types nullables permettent aux paramètres et aux types de retour d'accepter soit le type spécifié, soit null, en préfixant le nom du type par un point d'interrogation (par exemple, '?string')." } - { question: "Comment se comporte le type de retour 'void' ?", answer: "Une fonction déclarée avec un type de retour 'void' doit soit omettre l'instruction return, soit utiliser un simple 'return;'. Renvoyer une valeur, y compris 'null', déclenchera une erreur fatale." } - { question: "Qu'est-ce que la déstructuration symétrique de tableau ?", answer: "La déstructuration symétrique de tableau permet aux développeurs d'utiliser la syntaxe courte des tableaux ('[]') au lieu de 'list()' pour déballer des tableaux (par exemple, '[$a, $b] = $arr'), et prend en charge la spécification des clés." } - { question: 'Comment fonctionne la visibilité des constantes de classe ?', answer: "PHP 7.1 introduit la possibilité de déclarer des constantes de classe comme 'public', 'protected' ou 'private', correspondant aux règles de visibilité des propriétés et des méthodes." } published: '2026-05-31' --- # PHP 7.1 : Fonctionnalités majeures Et si vous pouviez intercepter trois types d'exceptions différents dans un seul bloc sans répéter les blocs catch redondants ? Ou définir des constantes de classe qui sont strictement masquées pour tout accès externe ? PHP 7.1 introduit ces capacités, apportant une sécurité de typage et une expressivité robustes aux architectures PHP modernes. Il améliore les systèmes de types et la syntaxe avec des types nullables, des fonctions void, la déstructuration symétrique de tableaux avec clés, la visibilité des constantes de classe et l'interception d'exceptions multiples (multi-catch). ## Table des matières * [Types nullables](#nullable-types) * [Fonctions void](#void-functions) * [Déstructuration symétrique de tableau](#symmetric-destructuring) * [Visibilité des constantes de classe](#constant-visibility) * [Pseudo-type `iterable`](#iterable-type) * [Intercepter plusieurs types d'exceptions (Multi-catch)](#multi-catch) * [Clés dans list / déstructuration courte](#destructuring-keys) * [Prise en charge des décalages négatifs de chaînes (negative offsets)](#negative-offsets) * [Extensions notables & stdlib](#extensions-stdlib) * [Recettes pratiques](#practical-recipes) * [Erreurs courantes](#common-mistakes) * [Limitations](#limitations) * [Changements non rétrocompatibles](#backward-incompatible) * [Dépréciations (à corriger tôt)](#deprecations) * [Autres changements](#other-changes) * [Quiz interactif](#interactive-quiz) * [Réflexions finales](#closing-thoughts) --- ## Types nullables Vous pouvez préfixer n'importe quel indicateur de type avec **`?`** pour autoriser **`null`** comme valeur valide en plus du type principal : ```php // src/UserService.php function findUser(int $id): ?User { return $id === 0 ? null : new User($id); } ``` > [!NOTE] > Le saviez-vous ? Dans PHP 7.0, un indicateur de type `User` était absolu : retourner `null` levait une TypeError. Les types nullables résolvent ce problème sans obliger les développeurs à abandonner complètement le typage. --- ## Fonctions void Les fonctions qui ne renvoient rien utilisent **`void`**. Seul un simple **`return;`** ou l'omission complète de `return` est autorisé. Renvoyer quoi que ce soit d'autre (y compris un **`return null;`** explicite) constitue une erreur de compilation. ```php // src/Notifier.php function notify(string $message): void { echo $message; return; // Un return vide est valide, retourner n'importe quelle valeur est une erreur de type } ``` > [!NOTE] > Le saviez-vous ? `void` est un type de retour uniquement. Vous ne pouvez pas l'utiliser pour typer un paramètre de fonction (par exemple, `function foo(void $x)` n'est pas valide). --- ## Déstructuration symétrique de tableau Déballez des tableaux à l'aide de la syntaxe courte des tableaux **`[]`** comme alternative à **`list()`** : ```php // src/Config.php [$host, $port] = ['127.0.0.1', 3306]; ``` Cette syntaxe peut également être utilisée dans les boucles `foreach` : `foreach ($data as [$id, $name])`. --- ## Visibilité des constantes de classe Les constantes peuvent avoir une visibilité **`public`**, **`protected`** ou **`private`** : ```php // src/PaymentGateway.php class PaymentGateway { private const API_KEY = 'secret-key'; public const DEFAULT_TIMEOUT = 30; } ``` > [!NOTE] > Le saviez-vous ? Les constantes ont une visibilité `public` par défaut si aucun modificateur de visibilité n'est déclaré, maintenant la rétrocompatibilité avec les anciennes versions de PHP. --- ## Pseudo-type `iterable` Correspond à toute valeur satisfaisant **`is_array()`** ou étant une instance de **`\Traversable`** : ```php // src/Collection.php function processItems(iterable $items): void { foreach ($items as $item) { // Fonctionne à la fois pour les tableaux et les objets de type générateur/itérateur } } ``` --- ## Intercepter plusieurs types d'exceptions (Multi-catch) Interceptez différentes exceptions dans un seul bloc à l'aide de l'opérateur **`|`** : ```php // src/ApiConnector.php try { // Exécuter la requête API } catch (ConnectionException | ResponseException $e) { // Gérer l'un ou l'autre type d'exception ici } ``` --- ## Clés dans list / déstructuration courte Vous pouvez spécifier des clés lors de la déstructuration de tableaux : ```php // src/UserProfile.php ['id' => $userId, 'name' => $username] = $user; ``` Cela fonctionne à la fois pour `list()` et pour la nouvelle syntaxe courte `[]`. --- ## Prise en charge des décalages négatifs de chaînes (negative offsets) Indexez les chaînes à partir de la fin en utilisant des nombres négatifs : ```php // src/StrHelper.php $lastChar = 'abcdef'[-1]; // 'f' $sub = substr('abcdef', -3, -1); // 'de' ``` Les décalages négatifs sont également pris en charge pour l'accès aux caractères individuels : `$str[-2] = 'z';`. --- ## Extensions notables & stdlib * **cURL HTTP/2** : Prise en charge du push HTTP/2 et des fonctionnalités multi-serveurs. * **OpenSSL AEAD** : Ajout de la prise en charge des modes AEAD (GCM et CCM). * **`session_gc()`** : Expose explicitement la collecte standard des sessions obsolètes (garbage collection). --- ## Recettes pratiques ### Signature de méthode nullable ```php // src/recipes.php public function setName(?string $name): void { $this->name = $name; } ``` ### Déballer des lignes de base de données avec des clés ```php // src/recipes.php foreach ($rows as ['id' => $id, 'role' => $role]) { // ... } ``` --- ## ⚠️ Erreurs courantes Voici les pièges typiques dans PHP 7.1 : ### 1. Retourner `null` depuis une fonction `void` Dans PHP 7.1, retourner explicitement `null` depuis une fonction marquée `void` déclenche une erreur fatale. ```php // src/BadVoid.php // Mauvais : Retourner explicitement null est interdit pour les retours void function doNothing(): void { return null; // Erreur fatale : A void function must not return a value } ``` ```php // src/GoodVoid.php // Bon : Utilisez un simple return ou omettez-le complètement function doNothingGood(): void { return; } ``` ### 2. Supposer qu'un type `iterable` n'accepte que des tableaux Vérifier `is_array()` sur un paramètre `iterable` peut exclure les générateurs ou les classes d'itérateurs, provoquant des erreurs d'exécution inattendues. ```php // src/BadIterable.php // Mauvais : Lève des erreurs si $items est un objet Traversable, et non un tableau function dumpItems(iterable $items) { echo count($items); // Erreur fatale si $items est un générateur (n'implémente pas Countable) } ``` ```php // src/GoodIterable.php // Bon : Convertir en tableau si nécessaire ou utiliser foreach (qui gère les deux cas) function dumpItemsGood(iterable $items) { foreach ($items as $item) { echo $item; } } ``` --- ## Limitations * **Types nullables** : Vous ne pouvez pas combiner les types nullables avec les types Union. Écrire `?int|string` est une erreur de syntaxe (les types Union sont introduits dans PHP 8.0). * **Visibilité des constantes** : Impose le contrôle d'accès mais ne prend pas en charge le typage des constantes de classe. Déclarer `public const int TIMEOUT = 10;` reste une erreur de syntaxe jusqu'à PHP 8.3. --- ## Changements non rétrocompatibles ### Noyau & types * **Erreur sur un nombre insuffisant d'arguments** : passer trop peu d'arguments à une fonction définie par l'utilisateur lève désormais une exception **`ArgumentCountError`** (au lieu d'un avertissement/Warning). * **Comportement des décalages de chaînes** : l'accès avec un index vide `[]` sur les chaînes **n'est plus silencieux** ni converti automatiquement. * **`iterable` est un mot réservé** : vous ne pouvez pas nommer une classe, une interface ou un trait `iterable`. --- ## Quiz interactif Testez vos connaissances sur PHP 7.1 : 1. **Laquelle des affirmations suivantes est vraie concernant une fonction ayant un type de retour `void` ?** * A) Elle doit retourner explicitement `null`. * B) Elle ne doit comporter aucune instruction `return`. * C) Elle peut utiliser un `return;` vide ou l'omettre. * D) Elle renvoie `false` par défaut.
Cliquez pour afficher la réponse **Bonne réponse : C** Une fonction `void` peut utiliser une instruction `return;` vide pour sortir plus tôt ou l'omettre complètement, mais retourner une valeur (même `null`) constitue une erreur de syntaxe.
2. **Quelle exception est levée lorsque trop peu d'arguments sont passés à une fonction utilisateur dans PHP 7.1 ?** * A) TypeError * B) ArgumentCountError * C) WarningException * D) Error
Cliquez pour afficher la réponse **Bonne réponse : B** PHP 7.1 transforme les avertissements d'arguments manquants en une exception interceptable de type `ArgumentCountError`.
3. **Comment définir une constante de classe qui ne peut être accédée qu'au sein de la classe elle-même ?** * A) `private const MY_CONST = 1;` * B) `const private MY_CONST = 1;` * C) `protected const MY_CONST = 1;` * D) `private MY_CONST = 1;`
Cliquez pour afficher la réponse **Bonne réponse : A** PHP 7.1 permet aux constantes de classe d'utiliser les modificateurs de visibilité standard : `public const`, `protected const`, ou `private const`.
--- ## Réflexions finales PHP 7.1 est une version fondamentale pour obtenir un **typage strict et propre** et des structures de données plus saines. Convertissez les anciennes structures `list()` en `[]`, ajoutez le préfixe `?` aux arguments facultatifs et adaptez vos captures d'exceptions pour préparer votre application aux versions PHP 7.2+.