Quels sont les types d'erreurs et d'exceptions en PHP ?

Question

Accepted Answer

PHP dispose de deux systèmes parallèles pour les problèmes : les **erreurs** traditionnelles (avertissements, notifications, erreurs fatales) et les **exceptions** (basées sur les objets, capturables avec try/catch). PHP moderne unifie une grande partie de cela sous une hiérarchie `Throwable`, et les bonnes pratiques favorisent les exceptions.

## Niveaux d'erreur traditionnels

```text
E_NOTICE   → minor issues (e.g. using an undefined variable) — script continues
E_WARNING  → non-fatal problems (e.g. include of a missing file) — continues
E_ERROR / Fatal → serious errors (e.g. calling an undefined function) — script HALTS
E_DEPRECATED → use of deprecated features
```

Ce sont les erreurs classiques de PHP, basées sur des niveaux. Les notifications et avertissements laissent le script continuer (mais signalent des problèmes) ; les erreurs fatales l'arrêtent.

## La hiérarchie Throwable (moderne, basée sur les objets)

```text
Throwable (interface)
  ├── Error      → internal PHP/engine errors (TypeError, DivisionByZeroError, ...)
  │                 — typically PROGRAMMING bugs
  └── Exception  → application-level exceptions (the ones you throw and catch)
        ├── RuntimeException, LogicException
        ├── InvalidArgumentException, etc.
        └── your custom exceptions
```

PHP moderne représente les problèmes sérieux sous forme d'**objets** implémentant `Throwable`, divisés en `Error` (niveau moteur, généralement des bugs comme `TypeError`) et `Exception` (erreurs applicatives que vous levez et gérez).

## Capturer avec try/catch

```php
try {
    $result = riskyOperation();
} catch (InvalidArgumentException $e) {     // catch a SPECIFIC type
    echo "Bad argument: " . $e->getMessage();
} catch (Throwable $e) {                     // catch anything (Error OR Exception)
    log($e);
} finally {
    cleanup();                                // always runs
}
```

Depuis PHP 7, même les `Error`s (comme `TypeError`) sont capturables en tant que `Throwable` — vous pouvez donc capturer à la fois les erreurs et les exceptions.

## Lever des exceptions

```php
function divide(int $a, int $b): float {
    if ($b === 0) {
        throw new InvalidArgumentException("Cannot divide by zero");   // raise
    }
    return $a / $b;
}
```

## Configurer la gestion des erreurs

```php
error_reporting(E_ALL);         // report ALL errors (development)
ini_set('display_errors', '0'); // production: DON'T show errors to users (log them instead)
set_error_handler(...);          // convert errors to exceptions, custom handling
```

## Pourquoi c'est important

Comprendre le système d'erreurs et d'exceptions de PHP est important pour écrire des applications robustes et déboguer efficacement.

Connaître les **niveaux d'erreur** traditionnels (notification/avertissement/fatal) vous aide à interpréter les messages de PHP et à reconnaître la gravité des problèmes, tandis que la compréhension de la hiérarchie moderne **`Throwable`** (la division entre les `Error`s au niveau moteur — généralement des bugs de programmation — et les `Exception`s applicatives que vous levez et capturez) est clé de la gestion moderne des erreurs en PHP.

Les compétences pratiques — utiliser `try/catch/finally` pour gérer les exceptions, capturer des types spécifiques, lever des exceptions significatives, et le fait que même les `Error`s sont capturables en tant que `Throwable` (depuis PHP 7) — sont des connaissances quotidiennes pour construire du code fiable.

Il est important de connaître la pratique en production de **journaliser les erreurs plutôt que de les afficher aux utilisateurs** (car les erreurs affichées divulguent des informations sensibles — une préoccupation de sécurité) est essentiel pour un déploiement sûr.

PHP moderne favorise l'approche basée sur les exceptions et orientée objet, donc comprendre les types d'erreurs/exceptions, comment les gérer correctement, et la configuration sécurisée des erreurs est une connaissance fondamentale pour écrire des applications PHP robustes, deboguables et sécurisées.