Ces fonctions permettent de gérer les erreurs et de les enregistrer. Vous pouvez définir les règles de traitement des erreurs et choisir la manière de les enregistrer : vous pouvez adapter le rapport d’erreurs à vos besoins.

Avec les fonctions d’enregistrements, vous pouvez envoyer directement les rapports à d’autres machines (ou même les envoyer par email à un pager), à l’historique système, ou encore sélectionner les erreurs les plus importantes et ne pas enregistrer les autres.

La fonction de niveau d’erreur vous permet de personnaliser le niveau et le type d’erreur noté : depuis les inoffensives alertes jusqu’aux erreurs personnalisées retournées par les fonctions.

Ces fonctions sont disponibles dans le module PHP standard, qui est toujours accessible.

Il n’y pas d’installation nécessaire pour utiliser ces fonctions, elles font parties du coeur de PHP.

Le comportement de ces fonctions est affecté par la configuration dans le fichier “php.ini”.

Tableau 1. Options de configuration

Pour plus de détails sur les constantes PHP_INI_*, reportez-vous à Annexe G.

Voici un éclaircissement sur l’utilisation des directives de configuration.

“error_reporting” entier

En PHP 4 et PHP 5, la configuration par défaut est “E_ALL” & ~”E_NOTICE”. Elle montre toutes les erreurs, sauf les “E_NOTICE”. Il est recommandé de les afficher durant le développement.

Note : Activer le rapport d’erreur de niveau “E_NOTICE” durant le développement a des avantages. En terme de débogage, les message d’alertes vous signalent des bogues potentiels dans votre code. Par exemple, l’utilisation de valeurs non initialisées est signalée. Il est aussi plus pratique pour trouver des coquilles, et, ainsi, gagner du temps. Les messages NOTICE vous signaleront aussi les mauvaises pratiques de codage. Par exemple “$arr[item]” doit toujours être écrit “$arr[’item’]” car PHP va considérer “item” comme une constante, au premier abord. Si cette constante n’est pas définie, alors il va l’utiliser comme une chaîne.

Note : En PHP 5, un nouveau niveau d’erreur nommé “E_STRICT” est disponible. Comme “E_STRICT” n’est pas inclus sans “E_ALL”, vous devez explicitement activer ce niveau d’erreur. Activer “E_STRICT” pendant le développement peut être bénéfique. Les messages STRICT vous aideront à utiliser la dernière et meilleure suggestion de méthode de codage, par exemple, vous alertera de l’utilisation de fonctions non recommandées.

En PHP 3, la configuration par défaut est “(E_ERROR | E_WARNING | E_PARSE)”, ce qui correspond à la même configuration qu’en PHP 4. Notez toutefois que les constantes ne sont pas supportées dans le “php3.ini” de PHP 3, et que le niveau d’erreur doit être spécifié numériquement, c’est à dire “7”.

“display_errors” boolean

Cette directive détermine si les erreurs doivent être affichées à l’écran ou non.

Note : C’est une directive nécessaire en développement mais qui ne doit jamais être utilisée sur un système en production. (e.g. systèmes connectés à Internet).

Note : Bien que display_errors peut être défini en cours d’exécution (avec la fonction ini_set()), il n’aura aucun effet si le script a des erreurs fatales, car l’action désirée au moment de l’exécution ne sera pas exécutée.

“display_startup_errors” boolean

Même si display_errors est activé, des erreurs peuvent survenir lors de la séquence de démarrage de PHP, et ces erreurs sont cachées. Avec cette option, vous pouvez les afficher, ce qui est recommandé pour le débogage. En dehors de ce cas, il est fortement recommandé de laisser display_startup_errors à off.

“log_errors” boolean

Note : Il est recommandé d’utiliser l’historique d’erreur, plutôt que d’afficher les erreurs sur les sites de production.

“log_errors_max_len” entier

“ignore_repeated_errors” boolean

“ignore_repeated_source” boolean

Ignore la source du message lors des messages répétés. Lorsque vous avez configuré cette option à On, vous n’enregistrerez pas les erreurs répétées provenant de fichiers et lignes de code différents.

“report_memleaks” boolean

“track_errors” boolean

“html_errors” boolean

“docref_root” string

Le nouveau format d’erreur contient une référence à une page décrivant l’erreur, ou la fonction ayant causé l’erreur. Pour le manuel, vous pouvez télécharger ce dernier dans votre langue, et configurer cette option pour qu’elle pointe sur lui. Si votre copie du manuel est accessible à ‘/manual/’, vous pouvez simplement utiliser docref_root=/manual/. De plus, vous devez configurer docref_ext pour qu’elle corresponde aux extensions de votre manuel. docref_ext=.html. Il est possible d’utiliser des références externes. Par exemple, vous pouvez utiliser docref_root=http://manual/en/ ou docref_root=”http://landonize.it/?how=url&theme=classic&filter=Landon&url=http%3A%2F%2Fwww.php.net%2F”

La plupart du temps, vous utilisez l’option docref_root avec un slash a la fin (’/’). Mais ce n’est pas obligatoire, comme le montre le second exemple ci-dessus.

Note : Cette directive est destiné à vous aider dans votre développement en rendant facile la consultation de la description d’une fonction. Ne jamais l’utiliser sur un système de production (e.g. système connecté à Internet).

“docref_ext” string

Note : La valeur de docref_ext doit commencer par un point ‘.’.

“error_prepend_string” string

La chaîne à placer avant les messages d’erreur.

“error_append_string” string

La chaîne à placer après les messages d’erreur.

“error_log” string

Nom du fichier où seront enregistrées les erreurs. Le fichier doit être accessible en écriture par l’utilisateur exécutant le serveur web. Si la valeur spéciale “syslog” est utilisée, les erreurs seront envoyées au système d’historique du serveur. Sous Unix, cela correspond à syslog(3) et sous Windows NT, à l’historique d’événement. L’historique n’est pas supporté sous Windows 95. Voir aussi : syslog(). Si cette directive n’est pas fixée, les erreurs sont envoyées au journal d’erreurs SAPI. Par exemple, s’il s’agit d’une erreur de journal dans Apache ou “stderr” dans CLI.

“warn_plus_overloading” boolean

Si cette option est activée, PHP va afficher une alerte lorsque l’opérateur d’addition (”+”) est utilisé avec des chaînes de caractères. Cela peut aider à trouver les erreurs où le plus est utilisé comme opérateur de concaténation au lieu de point (”.”). Cette option n’existe pas en PHP 4.

Les constantes listées ici sont toujours disponibles dans PHP.

Note : Vous pouvez utiliser ces constantes dans le fichier “php.ini” mais pas hors de PHP, comme dans le fichier “httpd.conf”, où vous devez utiliser les valeurs de champs de bits.

Tableau 2. Erreurs et historique

Les valeurs ci-dessus (numérique ou symbolique) sont utilisées pour constituer des champs de bits, qui spécifient le niveau de rapport d’erreur. Vous pouvez utiliser les opérateurs de bits pour combiner ces valeurs pour en faire des masques qui filtrent certaines erreurs. Notez bien que seuls ‘|’, ‘~’, ‘!’, ‘^’ et ‘&’ seront compris dans le fichier “php.ini”, et que aucun opérateur logique ne sera compris en “php3.ini”.

Ci-dessous, vous trouverez un exemple de gestion des erreurs par PHP. Il y est défini un gestionnaire d’erreur, qui enregistre les informations dans un fichier (au format XML), et envoie un courriel au développeur si l’erreur est critique.

<?php
// Nous allons faire notre propre gestion
error_reporting(0);
 
// Fonction spéciale de gestion des erreurs
function userErrorHandler($errno, $errmsg, $filename, $linenum, $vars)
{
    // Date et heure de l'erreur
    $dt = date("Y-m-d H:i:s (T)");
 
    // Définit un tableau associatif avec les chaînes d'erreur
    // En fait, les seuls niveaux qui nous interessent
    // sont E_WARNING, E_NOTICE, E_USER_ERROR,
    // E_USER_WARNING et E_USER_NOTICE
    $errortype = array (
                E_ERROR              => 'Erreur',
                E_WARNING            => 'Alerte',
                E_PARSE              => 'Erreur d\'analyse',
                E_NOTICE             => 'Note',
                E_CORE_ERROR         => 'Core Error',
                E_CORE_WARNING       => 'Core Warning',
                E_COMPILE_ERROR      => 'Compile Error',
                E_COMPILE_WARNING    => 'Compile Warning',
                E_USER_ERROR         => 'Erreur spécifique',
                E_USER_WARNING       => 'Alerte spécifique',
                E_USER_NOTICE        => 'Note spécifique',
                E_STRICT             => 'Runtime Notice',
                E_RECOVERABLE_ERROR => 'Catchable Fatal Error'
                );
    // Les niveaux qui seront enregistrés
    $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 . "</errornum>\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";
    
    // sauvegarde de l'erreur, et mail si c'est critique
    error_log($err, 3, "/usr/local/php4/error.log");
    if ($errno == E_USER_ERROR) {
        mail("phpdev@example.com","Critical User Error",$err);
    }
}
 
 
function distance($vect1, $vect2)
{
    if (!is_array($vect1) || !is_array($vect2)) {
        trigger_error("Incorrect parameters, arrays expected", E_USER_ERROR);
        return NULL;
    }
 
    if (count($vect1) != count($vect2)) {
        trigger_error("Vectors need to be of the same size", 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("Coordinate $i in vector 1 is not a number, using zero", 
                            E_USER_WARNING);
            $c1 = 0.0;
        }
        if (!is_numeric($c2)) {
            trigger_error("Coordinate $i in vector 2 is not a number, using zero", 
                            E_USER_WARNING);
            $c2 = 0.0;
        }
        $d += $c2*$c2 - $c1*$c1;
    }
    return sqrt($d);
}
 
$old_error_handler = set_error_handler("userErrorHandler");
 
// constante non définie, qui génère une alerte
$t = I_AM_NOT_DEFINED;
 
// définition de quelques vecteurs
$a = array (2, 3, "foo");
$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 erreur utilisateur
$t2 = distance ($b, "i am not an array")."\n";
 
// Génère une alerte
$t3 = distance ($a, $b)."\n";
 
?>

Voir aussi syslog().

Table des matières

debug_backtrace – Génère le contexte de débogagedebug_print_backtrace –  Affiche une backtrace error_get_last – Récupère la dernière erreur survenueerror_log – Stocke un message d’erreurerror_reporting – Fixe le niveau de rapport d’erreurs PHPrestore_error_handler – Réactive l’ancienne fonction de gestion des erreursrestore_exception_handler –  Réactive l’ancienne fonction de gestion d’exceptions set_error_handler –  Spécifie une fonction utilisateur comme gestionnaire d’erreurs set_exception_handler –  Définit une fonction utilisateur de gestion d’exceptions trigger_error – Déclenche une erreur utilisateuruser_error – Alias de trigger_error()