---
title: 'PHP 7.0 from 5.6: Zend Engine 3, Scalar Types, ??, <=> & Migration | DevSense'
description: 'Guide de mise à niveau PHP 7.0 : déclarations de types scalaires, types de retour, opérateur de coalescence nulle (??), opérateur spaceship (<=>), classes anonymes, Throwable, CSPRNG et changements incompatibles majeurs.'
faq:
    - { question: "Qu'est-ce que la déclaration de type scalaire en PHP 7.0 ?", answer: "PHP 7.0 permet aux développeurs d'imposer des types (int, float, string, bool) sur les paramètres de fonction. En déclarant 'declare(strict_types=1);' en haut d'un fichier, le transtypage automatique est désactivé." }
    - { question: "Comment fonctionne l'opérateur de coalescence nulle (??) ?", answer: "L'opérateur de coalescence nulle ('??') renvoie son premier opérande s'il existe et n'est pas nul ; sinon, il renvoie son second opérande. C'est un raccourci pour les vérifications courantes basées sur 'isset()'." }
    - { question: "À quoi sert l'opérateur spaceship (<=>) ?", answer: "L'opérateur spaceship ('<=>') compare deux expressions. Il renvoie -1 si le terme de gauche est inférieur à celui de droite, 0 s'ils sont égaux, et 1 si le terme de gauche est supérieur, rendant les fonctions de tri très lisibles." }
    - { question: 'Quelle est la différence entre Exception et Throwable en PHP 7.0 ?', answer: "PHP 7.0 introduit l'interface 'Throwable'. Tant 'Exception' que la nouvelle classe 'Error' (qui représente les erreurs du moteur) implémentent 'Throwable'. Vous devez intercepter 'Throwable' pour gérer les deux classes." }
published: '2026-05-31'
---
# PHP 7.0 : Fonctionnalités majeures

Et si vous pouviez doubler les performances de votre application du jour au lendemain simplement en mettant à jour le moteur de votre langage ? C'est exactement ce que PHP 7.0 a permis de faire. Propulsé par le nouveau Zend Engine 3, il a introduit des améliorations massives de vitesse tout en apportant des types scalaires stricts, des déclarations de types de retour et des opérateurs modernes comme la coalescence nulle. PHP 7.0 marque un bond monumental dans l'histoire de PHP, établissant les bases des applications web modernes, sûres et hautement performantes.

## Table des matières
* [Déclarations de types scalaires](#scalar-types)
* [Déclarations de types de retour](#return-types)
* [Opérateur de coalescence nulle (`??`)](#null-coalescing)
* [Opérateur spaceship (`<=>`)](#spaceship-operator)
* [Tableaux de constantes via `define()`](#constant-arrays)
* [Classes anonymes](#anonymous-classes)
* [Syntaxe d'échappement de point de code Unicode](#unicode-escape)
* [Déclarations d'importations groupées (Group use)](#group-use)
* [Interface Throwable et exceptions du moteur](#throwable-exceptions)
* [Fonctions CSPRNG](#csprng-functions)
* [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)

---

<a id="scalar-types"></a>
## Déclarations de types scalaires

Les paramètres scalaires peuvent utiliser le typage : **`int`**, **`float`**, **`string`** et **`bool`** :

```php
// src/Math.php
declare(strict_types=1);

function add(int $a, int $b): int 
{
    return $a + $b;
}
```

> [!NOTE]
> Le saviez-vous ? Sans `declare(strict_types=1);` au début du fichier, PHP reste en **mode coercitif**, ce qui signifie qu'il convertira silencieusement les chaînes de caractères comme `"5"` en entiers pour satisfaire aux vérifications de paramètres.

---

<a id="return-types"></a>
## Déclarations de types de retour

Définissez le type qu'une fonction est tenue de renvoyer :

```php
// src/Generator.php
function generateId(): string 
{
    return uniqid();
}
```

Si une instruction de retour ne correspond pas à ce type, PHP lèvera une exception de type **`TypeError`**.

---

<a id="null-coalescing"></a>
## Opérateur de coalescence nulle (`??`)

Raccourci syntaxique pour les vérifications `isset()` :

```php
// src/Config.php
$username = $_GET['user'] ?? 'anonymous';
```

Il peut être chaîné : `$value = $a ?? $b ?? $default;`.

---

<a id="spaceship-operator"></a>
## Opérateur spaceship (`<=>`)

Comparaison à trois voies renvoyant `-1`, `0` ou `1` :

```php
// src/SortHelper.php
usort($list, function($a, $b) {
    return $a <=> $b;
});
```

Utile pour les opérations de tri où les comparaisons standard nécessiteraient une logique conditionnelle verbeuse.

---

<a id="constant-arrays"></a>
## Tableaux de constantes via `define()`

Définir des constantes de type tableau au moment de l'exécution :

```php
// src/Constants.php
define('ALLOWED_ROLES', ['admin', 'editor', 'guest']);
```

Auparavant, les tableaux ne pouvaient être définis comme constantes qu'à l'intérieur des classes à l'aide du mot-clé `const`.

---

<a id="anonymous-classes"></a>
## Classes anonymes

Instancier des objets simples jetables :

```php
// src/LoggerProvider.php
$logger = new class {
    public function log(string $msg) {
        echo $msg;
    }
};
```

Utile pour simuler (mock) des interfaces lors des tests unitaires.

---

<a id="unicode-escape"></a>
## Syntaxe d'échappement de point de code Unicode

Intégrer des symboles Unicode directement dans les chaînes de caractères :

```php
// src/Emoji.php
echo "\u{1F600}"; // Affiche un emoji souriant 😀
```

---

<a id="group-use"></a>
## Déclarations d'importations groupées (Group use)

Importer proprement plusieurs classes depuis le même espace de noms :

```php
// src/Controller.php
use App\Models\{User, Post, Comment};
```

---

<a id="throwable-exceptions"></a>
## Interface Throwable et exceptions du moteur

Les erreurs fatales et récupérables sont désormais levées sous forme d'exceptions de type **`Error`**. Interceptez-les à l'aide de l'interface **`Throwable`** :

```php
// src/ErrorHandler.php
try {
    nonExistentFunction();
} catch (Throwable $t) {
    // Intercepte à la fois les erreurs du moteur et les exceptions utilisateur
    echo "Caught: " . $t->getMessage();
}
```

> [!NOTE]
> Le saviez-vous ? `Error` n'étend pas `Exception`. Intercepter `Exception` n'empêchera pas les erreurs du moteur, comme l'appel d'une fonction non définie, de faire planter votre script. Utilisez plutôt `Throwable`.

---

<a id="csprng-functions"></a>
## Fonctions CSPRNG

Générer des valeurs aléatoires cryptographiquement sécurisées directement depuis le système d'exploitation :

```php
// src/TokenGenerator.php
$bytes = random_bytes(32);
$number = random_int(1, 100);
```

Ces fonctions remplacent les générateurs non sécurisés comme `rand()` ou `mt_rand()` dans les contextes de sécurité.

---

<a id="common-mistakes"></a>
## ⚠️ Erreurs courantes

Voici les pièges typiques lors de la migration vers PHP 7.0 :

### 1. Oublier de déclarer le type strict
Sans déclarer explicitement le type strict par fichier, PHP s'exécute en mode coercitif et convertit silencieusement les valeurs des arguments.
```php
// src/BadStrict.php
// Mauvais : Le mode coercitif est actif, la chaîne \"10\" est convertie en entier silencieusement
function setAge(int $age) {
    return $age;
}
setAge("10"); // Aucune erreur n'est levée
```
```php
// src/GoodStrict.php
// Bon : Activer les types stricts tout en haut du fichier
declare(strict_types=1);

function setAgeGood(int $age) {
    return $age;
}
// setAgeGood("10"); // Lève une TypeError
```

### 2. Intercepter `Exception` pour gérer les pannes du moteur
De nombreux développeurs ont intercepté `Exception` en s'attendant à ce qu'elle gère des erreurs comme la division par zéro, ce qui échoue car les erreurs du moteur implémentent `Error`.
```php
// src/BadCatch.php
// Mauvais : La division par zéro lève un DivisionByZeroError (qui étend Error), contournant Exception
try {
    $value = 1 / 0;
} catch (Exception $e) {
    echo "Ce bloc n'est pas exécuté !";
}
```
```php
// src/GoodCatch.php
// Bon : Intercepter Throwable ou Error pour capturer les défaillances du moteur
try {
    $value = 1 / 0;
} catch (Throwable $e) {
    echo "Erreur interceptée : " . $e->getMessage();
}
```

---

<a id="limitations"></a>
## Limitations

* **Déclarations de types scalaires** : Ne peuvent pas être nullables par défaut. Déclarer `int $x` et passer `null` lèvera une exception TypeError (les types nullables arrivent avec PHP 7.1).
* **Déclarations de types de retour** : Ne peuvent pas être marquées comme retournant `void` (ajouté dans PHP 7.1) ou plusieurs types (types Union ajoutés dans PHP 8.0).

---

<a id="backward-incompatible"></a>
## Changements non rétrocompatibles

### Changements du noyau

* **Les balises ASP (`<% %>`) et les balises script (`<script language="php">`)** sont complètement supprimées.
* **`$HTTP_RAW_POST_DATA`** est supprimé ; utilisez `php://input` à la place.
* **Les blocs par défaut multiples dans un `switch`** lèvent une erreur de type ParseError.
* **Les variables globales et les appels dynamiques** sont analysés strictement de gauche à droite (par exemple, `$$foo['bar']` a un nouvel ordre d'évaluation).

---

<a id="interactive-quiz"></a>
## Quiz interactif

Testez vos connaissances sur PHP 7.0 :

1. **Quelle affirmation est vraie concernant le typage strict en PHP 7.0 ?**
   * A) Le typage strict est activé globalement via le fichier php.ini.
   * B) Le typage strict doit être déclaré en haut de chaque fichier dans lequel on le souhaite.
   * C) PHP 7.0 s'exécute uniquement en mode strict et n'a pas de mode coercitif.
   * D) Le typage strict s'applique uniquement aux types de retour, pas aux paramètres.

   <details>
   <summary>Cliquez pour afficher la réponse</summary>
   
   **Bonne réponse : B**  
   Le typage strict est déclaré par fichier à l'aide de `declare(strict_types=1);`.
   </details>

2. **Quelle classe n'étend PAS Exception mais implémente Throwable en PHP 7.0 ?**
   * A) RuntimeException
   * B) Error
   * C) BadMethodCallException
   * D) InvalidArgumentException

   <details>
   <summary>Cliquez pour afficher la réponse</summary>
   
   **Bonne réponse : B**  
   La nouvelle classe `Error` et ses sous-classes (comme `TypeError` ou `ParseError`) implémentent `Throwable` mais n'héritent pas d'`Exception`.
   </details>

3. **Quel est le type de retour de l'opérateur spaceship (`<=>`) ?**
   * A) Booléen
   * B) Float
   * C) Entier (`-1`, `0` ou `1`)
   * D) Chaîne de caractères

   <details>
   <summary>Cliquez pour afficher la réponse</summary>
   
   **Bonne réponse : C**  
   L'opérateur spaceship compare deux valeurs et renvoie `-1` si le terme de gauche est plus petit, `0` s'ils sont égaux, et `1` si le terme de gauche est plus grand.
   </details>

---

<a id="closing-thoughts"></a>
## Réflexions finales

PHP 7.0 est un **jalon révolutionnaire** dans le développement web. Assurez-vous que votre serveur exécute bien Zend Engine 3, mettez à niveau votre base de code patrimoniale en supprimant les balises ASP, convertissez les fonctions aléatoires non sécurisées en équivalents CSPRNG, et réécrivez les blocs d'interception d'Exception en Throwable.