6.3 Gestion des erreurs
[Notes en ligne] 

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

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().
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.
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.
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()
Sommaire: