Gestion des erreurs

Manuel PHP
Précédent |  | Suivant

# Chapitre 15. Gestion des erreurs

Il y a plusieurs types d'erreur et d'alerte.

Tableau 15-1. Types d'erreur PHP

Valeur | Constante | Description | Note
--- | --- | --- | ---
1 | E_ERROR | Erreur fatale d'exécution |
2 | E_WARNING | Alerte d'exécution ( erreur non-fatale ) |
4 | E_PARSE | Erreur de compilation |
8 | E_NOTICE | Notes d'exécution (moins critique que les alertes) |
16 | E_CORE_ERROR | Erreurs qui surviennent lors de l'initialisation de PHP | PHP 4 seulement
32 | E_CORE_WARNING | Alertes qui surviennent lors de l'initialisation de PHP | PHP 4 seulement
64 | E_COMPILE_ERROR | Erreur fatale de compilation | PHP 4 seulement
128 | E_COMPILE_WARNING | Alerte de compilation (erreur non fatale) | PHP 4 seulement
256 | E_USER_ERROR | Erreur générée par l'utilisateur | PHP 4 seulement
512 | E_USER_WARNING | Alerte générée par l'utilisateur | PHP 4 seulement
1024 | E_USER_NOTICE | Note générée par l'utilisateur | PHP 4 seulement
| E_ALL | Toutes les erreurs ci-dessus |

Les valeurs ci-dessus (numériques ou symboliques) sont utilisées pour construire un champs de bit, qui spécifie quelles erreurs rapporter. Vous pouvez utiliser les opérateurs de bits pour combiner ces valeurs et conserver uniquement celle qui vous intéresse. Notez que seuls, '|', '~', '!', et '&' seront utilisables dans `php.ini`, et qu'aucun opérateur ne sera utilisable dans `php3.ini`.

En PHP 4, la valeur par défaut de error_reporting est à `E_ALL & ~E_NOTICE`, ce qui signifie que toutes les erreurs et alertes seront affichées, mais pas les notes. En PHP 3, la valeur par défaut est `(E_ERROR | E_WARNING | E_PARSE)`, c'est-à-dire la même chose. Notez bien que ces constantes ne sont pas supportées dans le fichier `php3.ini` de PHP 3, la valeur de error_reporting doit être numérique, c'est-à-dire `7`.

La valeur initiale peut être modifiée dans le fichier `php.ini`, avec la directive error_reporting, dans le fichier de configuration d'Apache `httpd.conf`, avec la directive php_error_reporting (php3_error_reporting pour PHP 3), et enfin, dans le script même, en utilisant la fonction error_reporting().

Avertissement
Lorsque vous portez votre code ou vos serveurs de PHP 3 en PHP 4 vous devez vérifier les options et les appels à error_reporting(). Sinon, vous courrez le risque d'inactiver certains types d'erreurs et notamment E_COMPILE_ERROR. Cela peut conduire à des documents vides, sans aucun retour d'erreur.

Toutes les expressions PHP peuvent être appelées avec le préfixe "@", qui annule le rapport d'erreur pour cette expression en particulier. Si une erreur survient durant une telle expression, et que l'option de suivi des erreurs est activée, vous pourrez trouver le message d'erreur dans la variable globale, `$php_errormsg`.

> Note : Le préfixe opérateur @ ne supprimera pas les messages liés aux erreurs d'analyse.

Avertissement
Actuellement, le préfixe @, opérateur de rapport d'erreur désactive tous les rapports, y compris les erreurs critiques qui interrompent le script. Entre autre, cela signifique que si vous utilisez @ pour supprimer des erreurs dans une fonction qui n'existe pas, ou qui a été mal orthographiée, le script sera terminé sans aucune indication.

Ci-dessous, voici un exemple de gestion des erreurs avec PHP. On définit une fonction de gestion des erreurs qui enregistre les informations dans un fichier (au format XML), et envoie un email au développeur en cas d'erreur critique.

Exemple 15-1. Utiliser le contrôle d'erreur dans un script
    <?php
    // Nous effectuons nous-même notre contrôle d'erreur.
    error_reporting(0);
    // Fonction de gestion des erreurs utilisateur
    function usererrorhandler($errno, $errmsg, $filename, $linenum, $vars) {
        // timestamp pour dater l'erreur
        $dt = date("Y-m-d H:i:s (T)");
        // definit un tableau associatif avec les chaînes d'erreur
        // en réalité, les seules entrées que nous considérerons
        // seront 2,8,256,512 et 1024
        $errortype = array(
                    1   =>  "Erreur",
                    2   =>  "Alerte",
                    4   =>  "Erreur d'analyse",
                    8   =>  "Note",
                    16  =>  "Erreur interne",
                    32  =>  "Alerte interne",
                    64  =>  "Erreur de compilation",
                    128 =>  "Alerte  de compilation",
                    256 =>  "Erreur utilisateur",
                    512 =>  "Alerte utilisateur",
                    1024=>  "Note utilisateur"
                    );
        // ensemble d'erreur pour lesquelles une trace sera conservée
        $user_errors = array(E_USER_ERROR, E_USER_WARNING, E_USER_NOTICE);
        $err = "<errorentry>\n";
        $err .= "\t<datetime>".$dt."</datetime>\n";
        $err .= "\t<errornum>".$errno."</errnumber>\n";
        $err .= "\t<errortype>".$errortype[$errno]."</errortype>\n";
        $err .= "\t<errormsg>".$errmsg."</errormsg>\n";
        $err .= "\t<scriptname>".$filename."</scriptname>\n";
        $err .= "\t<scriptlinenum>".$linenum."</scriptlinenum>\n";
        if (in_array($errno, $user_errors))
            $err .= "\t<vartrace>".wddx_serialize_value($vars,"Variables")."</vartrace>\n";
        $err .= "</errorentry>\n\n";
        // pour test
        // echo $err;
        // sauve l'erreur dans le fichier, et emaile moi si l'erreur est critique
        error_log($err, 3, "/usr/local/php4/error.log");
        if ($errno == E_USER_ERROR)
            mail("phpdev@mydomain.com","Critical User Error",$err);
    }
    function distance($vect1, $vect2) {
        if (!is_array($vect1) || !is_array($vect2)) {
            trigger_error("Paramètres incorrects : arrays attendus", E_USER_ERROR);
            return NULL;
        }
        if (count($vect1) != count($vect2)) {
            trigger_error("Les vecteurs doivent être de la même taille", E_USER_ERROR);
            return NULL;
        }
        for ($i=0; $i<count($vect1); $i++) {
            $c1 = $vect1[$i]; $c2 = $vect2[$i];
            $d = 0.0;
            if (!is_numeric($c1)) {
                trigger_error("La coordonnée $i du vecteur 1 n'est pas un nombre. Remplacée par zéro",
                                E_USER_WARNING);
                $c1 = 0.0;
            }
            if (!is_numeric($c2)) {
                trigger_error("La coordonnée $i du vecteur 2 n'est pas un nombre. Remplacée par zéro",
                                E_USER_WARNING);
                $c2 = 0.0;
            }
            $d += $c2*$c2 - $c1*$c1;
        }
        return sqrt($d);
    }
    $old_error_handler = set_error_handler("userErrorHandler");
    // Constante indéfinie, génère une alerte
    $t = I_AM_NOT_DEFINED;
    // definition de quelques "vecteurs"
    $a = array(2,3,"bla");
    $b = array(5.5, 4.3, -1.6);
    $c = array(1,-3);
    // génère une erreur utilisateur
    $t1 = distance($c,$b)."\n";
    // génère une autre erreur utilisateur
    $t2 = distance($b,"i am not an array")."\n";
    // génère une alerte
    $t3 = distance($a,$b)."\n";
    ?>

Ceci est un exemple simple, qui montre comment utiliser les fonctions de Gestions des erreurs.

Voir aussi error_reporting(), error_log(), set_error_handler(), restore_error_handler(), trigger_error(), user_error()

Précédent | Sommaire | Suivant
Caractéristiques | Niveau supérieur | Création d'images