En quoi consiste la gestion des erreurs et des…

La gestion des erreurs et des exceptions en PHP permet de contrôler l'exécution du programme en cas de situations incorrectes, d'éviter les défaillances fatales et de fournir des informations significatives à l'utilisateur.

Erreurs

Les erreurs sont des problèmes qui surviennent au niveau de l'interpréteur PHP. Elles peuvent être syntaxiques, logiques ou survenir lors de l'accès à des ressources inexistantes. Les niveaux d'erreur sont déterminés par des constantes (E_ERROR, E_WARNING, E_NOTICE, etc.) et peuvent être configurés avec error_reporting et display_errors.

Pour gérer les erreurs, on utilise des fonctions personnalisées enregistrées avec set_error_handler(). Cette fonction intercepte les erreurs (sauf E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING), permettant de les enregistrer, d'afficher un message, d'arrêter l'exécution du script ou de continuer.

<?php
// Fonction personnalisée de gestion des erreurs
function myErrorHandler($errno, $errstr, $errfile, $errline) {
    // Enregistrement de l'erreur
    error_log("Erreur [$errno]: $errstr dans le fichier $errfile à la ligne $errline");

    // Affichage du message à l'utilisateur (selon l'environnement)
    if (ini_get('display_errors')) {
        echo "Une erreur est survenue: [$errno] $errstr<br>";
        echo "Dans le fichier: $errfile à la ligne: $errline<br>";
    }

    // Arrêt de l'exécution en cas d'erreurs critiques
    if ($errno == E_USER_ERROR) {
        die("Erreur critique. Script arrêté.");
    }

    // Continuer avec le traitement standard de PHP si la fonction retourne false
    // return false;
}

// Enregistrement de la fonction gestionnaire
set_error_handler("myErrorHandler");

// Exemple d'erreur
// echo $undeclaredVar; // Générera E_NOTICE

Exceptions

Les exceptions sont des objets qui sont lancés dans des situations exceptionnelles. Elles permettent de structurer le code et de gérer le flux d'exécution de manière plus flexible que la gestion traditionnelle des erreurs.

Elles sont gérées avec la construction try...catch...finally:

try: Bloc de code où une exception peut survenir.
catch: Bloc qui s'exécute si une exception du type spécifié est lancée dans try ou dans un autre catch. Plusieurs catch peuvent être utilisés pour différents types.
finally: (disponible depuis PHP 5.5) Bloc qui s'exécute toujours, indépendamment de si une exception a été lancée ou non et si elle a été attrapée.

<?php
function divide($a, $b) {
    if ($b === 0) {
        throw new Exception("Division par zéro impossible.");
    }
    return $a / $b;
}

try {
    echo divide(10, 2) . "<br>";
    echo divide(5, 0) . "<br>"; // Une exception sera générée
    echo "Ce code ne sera pas exécuté si la ligne précédente lance une exception.";
} catch (Exception $e) {
    echo "Exception attrapée: " . $e->getMessage() . "<br>";
    // On peut aussi obtenir le fichier, la ligne et la pile d'appels
    // echo "Dans le fichier: " . $e->getFile() . " à la ligne: " . $e->getLine() . "<br>";
    // echo "Trace de la pile:<pre>" . $e->getTraceAsString() . "</pre>";
} finally {
    // Ce bloc s'exécute toujours
    echo "Opération terminée.<br>";
}

Classes d'exceptions

PHP fournit la classe de base Exception, dont héritent d'autres classes d'exceptions intégrées (par exemple, InvalidArgumentException, RuntimeException). Il est possible de créer ses propres classes d'exceptions en héritant de Exception ou de ses descendants, pour une représentation plus précise des types d'erreurs.

<?php
class MyCustomException extends Exception {
    // On peut ajouter ses propres propriétés et méthodes
}

function processData($data) {
    if (empty($data)) {
        throw new MyCustomException("Données manquantes pour le traitement.");
    }
    // ... traitement des données
}

try {
    processData([]);
} catch (MyCustomException $e) {
    echo "Exception personnalisée attrapée: " . $e->getMessage() . "<br>";
} catch (Exception $e) {
    echo "Autre exception attrapée: " . $e->getMessage() . "<br>";
}

Principes généraux

Ne capturez pas les erreurs que vous ne pouvez pas traiter. Si vous ne savez pas comment réagir correctement à une erreur, laissez-la remonter pour qu'un autre gestionnaire la traite.
Les exceptions conviennent mieux aux situations attendues mais exceptionnelles (par exemple, erreur de saisie utilisateur, impossibilité de se connecter à la base de données). Les erreurs indiquent souvent des problèmes dans le code ou l'environnement.
Enregistrez les erreurs et exceptions. C'est crucial pour le débogage et la surveillance de l'application.
Ne divulguez pas d'informations sensibles à l'utilisateur dans les messages d'erreur.
Utilisez set_exception_handler() pour gérer les exceptions non attrapées. Cela permet d'éviter les erreurs fatales et la dégradation gracieuse.

<?php
// Gestionnaire d'exceptions non attrapées
function myExceptionHandler($exception) {
    error_log("Exception non attrapée: " . $exception->getMessage());
    // Redirection vers une page d'erreur, affichage d'un message général, etc.
    echo "Une erreur inattendue est survenue sur le serveur. Veuillez réessayer plus tard.";
}

set_exception_handler('myExceptionHandler');

// Ce code lancera une exception qui sera attrapée par myExceptionHandler
// throw new Exception("Ceci est une exception non attrapée.");

Ainsi, une utilisation appropriée des mécanismes de gestion des erreurs et des exceptions est essentielle pour créer une application PHP fiable et maintenable.

En quoi consiste la gestion des erreurs et des exceptions en PHP?