Erreurs PHP

Rencontrer des erreurs est une partie normale de l'écriture de code PHP. Plus vite vous pouvez lire une erreur et comprendre quel niveau elle représente, pourquoi PHP l'a déclenchée, et comment y répondre, plus vite vous livrez du code fonctionnel. Cette page explique les niveaux d'erreur de PHP (les constantes E_*), la différence entre les erreurs et les exceptions dans le PHP moderne, ainsi qu'un flux de travail pratique pour les signaler, les journaliser et les gérer.

Niveaux d'erreur PHP

Lorsque PHP détecte un problème, il le lève à un niveau spécifique, identifié par une constante E_*. Le niveau vous indique la gravité du problème et si le script continue de s'exécuter. Vous combinez ces constantes avec error_reporting() et la directive error_reporting de php.ini pour décider quels niveaux sont affichés ou journalisés.

Ce sont des constantes de masque de bits, vous les combinez donc avec l'opérateur OR bit à bit (|) et excluez des niveaux avec & plus ~ :

<?php
// Report everything except notices and deprecations
error_reporting(E_ALL & ~E_NOTICE & ~E_DEPRECATED);

Important : Depuis PHP 8.0, de nombreux anciens avertissements et notices ont été promus en exceptions Error lancées (par exemple, lire une clé de tableau non définie génère maintenant un avertissement, tandis qu'appeler une méthode non définie lance une Error). Savoir si un problème est une erreur levée ou une exception lancée détermine la façon dont vous la capturez — voir ci-dessous.

Erreurs vs. Exceptions

PHP dispose de deux mécanismes liés mais distincts :

• Les erreurs traditionnelles sont levées par le moteur et acheminées via error_reporting, display_errors, et un gestionnaire optionnel défini avec set_error_handler(). Ce ne sont pas des objets que vous pouvez catch (à moins que votre gestionnaire ne les convertisse).
• Les exceptions sont des objets que vous throw et catch avec des blocs try/catch. Depuis PHP 7, les problèmes fatals du moteur sont également lancés en tant qu'objets Error (comme TypeError ou DivisionByZeroError), et Exception comme Error implémentent l'interface Throwable — donc catch (\Throwable $e) capture tout ce qui est capturable.

<?php
try {
    // intdiv() throws a DivisionByZeroError on division by zero
    echo intdiv(10, 0);
} catch (\Throwable $e) {
    echo get_class($e) . ": " . $e->getMessage();
}
// Output: DivisionByZeroError: Division by zero

Causes courantes des erreurs PHP

La plupart des erreurs remontent à un petit ensemble de causes :

• Erreurs de syntaxe — un point-virgule manquant ou une accolade non appariée (E_PARSE).
• Symboles non définis — utilisation d'une variable, constante, fonction ou clé de tableau qui n'existe pas.
• Incompatibilités de types — passage du mauvais type à un paramètre typé (lance TypeError).
• Fonctionnalités dépréciées — fonctions ou syntaxe destinées à être supprimées (E_DEPRECATED).
• Limites de ressources — épuisement de memory_limit ou dépassement de max_execution_time.
• Défaillances externes — un fichier manquant, ou une connexion à une base de données/API qui refuse ou expire.
• Exceptions non capturées — un throw sans catch correspondant, ce qui devient une erreur fatale.

<?php
// Reading an undefined variable raises an E_WARNING and yields null
echo $undefined_variable ?? "fallback";
// Output: fallback

L'opérateur de fusion null (??) ci-dessus est la façon idiomatique de lire une valeur qui pourrait être non définie sans déclencher un avertissement.

Configuration du rapport d'erreurs

Contrôlez quels niveaux remontent et où ils vont. En développement, affichez tout ; en production, masquez les erreurs aux utilisateurs mais journalisez-les.

<?php
// Development: show all errors on screen
error_reporting(E_ALL);
ini_set('display_errors', '1');

// Production: hide from users, write to the error log instead
// error_reporting(E_ALL);
// ini_set('display_errors', '0');
// ini_set('log_errors', '1');

Les paramètres php.ini équivalents sont error_reporting, display_errors, log_errors et error_log. Pour un contrôle programmatique, voir error_reporting() et pour inspecter la dernière erreur, utilisez error_get_last().

Gestion des erreurs dans le code

Il existe trois outils complémentaires :

1. Capturer les exceptions avec try/catch pour qu'une défaillance récupérable ne fasse pas planter le script :

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

try {
    echo safeDivide(10, 0);
} catch (InvalidArgumentException $e) {
    echo "Handled: " . $e->getMessage();
}
// Output: Handled: Cannot divide by zero

2. Installer un gestionnaire d'erreurs personnalisé avec set_error_handler() pour convertir les erreurs traditionnelles en exceptions ou pour les journaliser dans votre propre format :

<?php
set_error_handler(function (int $level, string $message, string $file, int $line) {
    // Turn a traditional warning/notice into an ErrorException so it can be caught
    throw new ErrorException($message, 0, $level, $file, $line);
});

try {
    // Reading a missing file raises an E_WARNING, now converted to an exception
    $contents = file_get_contents('/no/such/file.txt');
} catch (\Throwable $e) {
    echo "Caught: " . $e->getMessage();
}
// Output: Caught: file_get_contents(/no/such/file.txt): Failed to open stream: No such file or directory

3. Déclencher vos propres erreurs avec trigger_error() pour signaler des problèmes au niveau de l'application via le même pipeline que les erreurs du moteur.

Bonnes pratiques

• Définissez display_errors à 0 en production — les traces de pile divulguées représentent un risque de sécurité. Utilisez log_errors et un error_log configuré à la place.
• Développez avec error_reporting(E_ALL) pour que les notices et les dépréciations apparaissent tôt.
• Préférez catch (\Throwable $e) au niveau supérieur pour capturer à la fois Exception et Error.
• Ne masquez jamais les problèmes avec l'opérateur @ ; corrigez la cause ou gérez-la explicitement.
• Centralisez la journalisation avec error_log() pour que chaque défaillance soit enregistrée au même endroit.

Conclusion

Lire une erreur PHP commence par son niveau et par savoir si c'est une erreur levée ou une exception lancée. Avec error_reporting() ajusté selon l'environnement, un gestionnaire personnalisé qui achemine les erreurs vers le système d'exceptions, et try/catch autour du code susceptible d'échouer, vous pouvez diagnostiquer les problèmes rapidement et maintenir la résilience en production. Continuez avec Exceptions PHP et error_reporting() pour approfondir.

Pratique