Mis à jour le mercredi 30 octobre 2013
  • Facile
Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Introduction du cours

En tant que programmeur PHP, vous avez sûrement déjà eu l'occasion de rencontrer des erreurs, avertissements et notices : ils sont très utiles pour le développement, car ils permettent de localiser « facilement » les problèmes dans votre code. Cependant, lorsque votre site est en ligne, mieux vaut les désactiver pour des raisons de sécurité et d'esthétique. :p

Dans ce tutoriel, je vais vous expliquer comment gérer vous-même l'affichage de ces erreurs, et comment les personnaliser grâce aux fonctions d'erreur mises à notre disposition par PHP.

Empêcher tout affichage

Il existe une méthode très simple, mais très efficace pour éviter l'affichage des erreurs, qui est d'appeler la fonction error_reporting() en lui passant 0 en argument, argument servant à indiquer le niveau de rapport d'erreurs.

Exemple :

<?php
error_reporting(0);
 
// On affiche une variable non initialisée, ce qui devrait provoquer une notice.
echo $var;
 
// On divise par 0, ce qui devrait provoquer un avertissement.
$var2 = 5/0;
 
// On inclut un fichier qui n'existe pas, ce qui devrait provoquer un avertissement et une erreur fatale.
require('non-existing');
?>

Vous pouvez aussi directement changer la valeur de error_reporting dans le php.ini, si vous y avez accès et si vous voulez supprimer l'affichage des erreurs par défaut.

Si vous voulez empêcher l'affichage d'une erreur pour une fonction en particulier, vous pouvez vous contenter de la faire précéder d'un « @ ».
Exemple :

<?php
if(!@include '/non-existing') {
    echo 'Le fichier n\'existe pas !';
}
?>

Cette solution est efficace, mais le visiteur ne comprendra pas nécessairement pourquoi l'action n'a pas été effectuée correctement, et c'est là que la fonction set_error_handler() intervient.

Votre fonction de gestion d'erreurs

set_error_handler() va en fait ignorer le rapport d'erreurs standard de PHP, et définir une fonction de callback qui gérera les erreurs ; en particulier, il vous sera possible d'en déclencher grâce à trigger_error() (que nous verrons plus loin).

Une fonction de callback est définie de la manière suivante sur Wikipédia :

Citation : Wikipédia

En informatique, une fonction de rappel (callback en anglais) est une fonction qui est passée en argument à une autre fonction. Cette dernière peut alors faire usage de cette fonction de rappel comme de n'importe quelle autre fonction, alors qu'elle ne la connaît pas par avance.

En PHP, il existe plusieurs sortes de fonctions et pour chacune, la syntaxe de son appel en tant que fonction de callback est différente.

  • Les fonctions « simples » ; j'entends par là les fonctions que M@teo21 vous apprend à créer dans son tutoriel.
    Dans ce cas, on passe le nom de la fonction comme une chaîne de caractères.
    Exemple :

    <?php
    set_error_handler('ma_fonction');
    ?>
    
  • Les fonctions anonymes, c'est-à-dire créées à l'aide de create_function(). Dans ce cas, on pourra passer directement le create_function ou la variable qui le contient en paramètre.
    Exemple :

    <?php
    set_error_handler(create_function(...));
    // Ou :
    $ma_fonction = create_function(...);
    set_error_handler($ma_fonction);
    ?>
    
  • Les méthodes de classe appelées de manière statique.
    Vous ne le savez peut-être pas, mais il existe plusieurs façons de programmer en PHP : la programmation fonctionnelle (comme enseigné dans les cours de M@teo21) et la POO. Je ne vais pas entrer dans les détails ici mais sachez qu'en POO, les fonctions sont réparties dans des classes et sont appelées « méthodes ».
    Une méthode est donc caractérisée par son nom et par le nom de sa classe, il nous faudra donc passer les deux dans un array.
    Exemple :

    <?php
    set_error_handler(array('ma_classe', 'ma_methode'));
    ?>
    
  • Les méthodes d'un objet instancié.
    En POO, on manipule un type de variable particulier : les « objets », qu'on initialise de la façon suivante :

    <?php
    $obj = new ma_classe();
    ?>
    

    $obj est alors appelé « objet instancié ».
    On pourra alors utiliser le callback d'une méthode de $obj en passant dans un array une référence de $obj et du nom de la méthode.
    Exemple :

    <?php
    $obj = new ma_classe();
    set_error_handler(array(&$obj, 'ma_methode'));
    ?>
    

    Note : la syntaxe &$obj signifie qu'on passe une référence de $obj. Une référence est une sorte de raccourci vers une variable ; au lieu de copier sa valeur comme on le fait d'habitude, on copie son emplacement dans la mémoire, on donne un autre nom à la variable et par conséquent, si la référence est modifiée, la variable le sera également.

Personnellement, je vais utiliser une fonction « simple », mais la démarche est similaire dans tous les cas.
La fonction doit avoir au moins 2 arguments :

  • le type d'erreur (il existe des constantes que nous verrons plus loin) ;

  • le message de l'erreur.

En outre, il existe 3 arguments optionnels :

  • le nom du fichier dans laquelle l'erreur a été rencontrée ;

  • la ligne de l'erreur dans le fichier ;

  • le contexte de l'erreur ;

Je ne me servirai pas du dernier, mais libre à vous d'aller voir la doc pour plus d'informations sur ce paramètre.

Exemple de fonction :

<?php
function my_error_handler($no, $str, $file, $line){
    echo '<p>Erreur ['.$no.'] : '.$str.'<br/>';
    echo 'Survenue dans le fichier : "'.$file.'" à la ligne '.$line.'.</p>';
}
?>

$no contient en fait le type de l'erreur sous forme numérique, chacune de ces valeurs correspond à une constante ; une liste exhaustive de ces constantes est disponible dans la doc (ici).
Dans cette liste, vous pouvez voir apparaître 3 constantes particulières : E_USER_ERROR, E_USER_WARNING et E_USER_NOTICE.
Ces constantes sont celles que nous manipulerons et que nous enverrons à la fonction de gestion d'erreurs à l'aide de trigger_error(). Ainsi, nous pouvons définir des comportements différents de la fonction suivant le type d'erreur.

Exemple :

<?php
function my_error_handler($no, $str, $file, $line){
    switch($no){
        // Erreur fatale
        case E_USER_ERROR:
            echo '<p><strong>Erreur fatale</strong> : '.$str.'</p>';
            exit;//on arrete le script
            break;
        
        // Avertissement
        case E_USER_WARNING:
            echo '<p><strong>Avertissement</strong> : '.$str.'</p>';
            break;
        
        // Note
        case E_USER_NOTICE:
            echo '<p><strong>Note</strong> : '.$str.'</p>';
            break;
        
        // Erreur générée par PHP
        default:
            echo '<p><strong>Erreur inconnue</strong> ['.$no.'] : '.$str.'<br/>';
            echo 'Dans le fichier : "'.$file.'", à la ligne '.$line.'.</p>';
            break;
    }
}
?>

Ce n'est qu'un exemple, vous pouvez très bien changer l'affichage pour qu'il soit similaire à celui du Site du Zéro, par exemple, avec des liens pour aller à la page suivante / précédente, ou encore ajouter les autres types d'erreurs.

Note : error_reporting() n'influera pas sur le niveau des erreurs qui seront rapportées à votre fonction, et par défaut, celui-ci sera maximum. Pour changer ce comportement, on utilisera le 2e argument de set_error_handler().

Voilà ! :) Maintenant, il reste à savoir comment déclencher nos erreurs et ça tombe bien, c'est justement le sujet de la prochaine partie. :p

Déclencher vos erreurs

Comme je vous l'avais annoncé dans la partie précédente, la fonction qui déclenche les erreurs est trigger_error() (qui se traduit d'ailleurs par « déclencher erreur » :p ) ; celle-ci est très simple d'utilisation, vous allez voir.

trigger_error() nécessite 2 arguments :

  • le message d'erreur ;

  • le type d'erreur (optionnel, par défaut E_USER_NOTICE).

Le nom du fichier et le numéro de la ligne sont transmis automatiquement.
Vous ne pouvez déclencher que des erreurs de la famille E_USER, ou vous aurez droit à un warning.

Maintenant que vous savez tout, démonstration. :p

<?php
function my_error_handler($no, $str, $file, $line){
    switch($no){
        // Erreur fatale
        case E_USER_ERROR:
            echo '<p><strong>Erreur fatale</strong> : '.$str.'</p>';
            exit; // On arrête le script
            break;
        
        // Avertissement
        case E_USER_WARNING:
            echo '<p><strong>Avertissement</strong> : '.$str.'</p>';
            break;
        
        // Note
        case E_USER_NOTICE:
            echo '<p><strong>Note</strong> : '.$str.'</p>';
            break;
        
        // Erreur générée par PHP
        default:
            echo '<p><strong>Erreur inconnue</strong> ['.$no.'] : '.$str.'<br/>';
            echo 'Dans le fichier : "'.$file.'", à la ligne '.$line.'.</p>';
            break;
    }
}
 
set_error_handler('my_error_handler');
 
if(empty($_GET['empty'])){
    trigger_error('Vous devez préciser la valeur de "empty" ou une valeur nulle lui sera imposée.', E_USER_NOTICE);
    $empty = 0;
}
 
if(empty($_GET['div']))
    trigger_error('Vous ne pouvez pas diviser par 0', E_USER_WARNING);
else
    echo (5/$_GET['div']);
 
if(!is_file('non-existing'))
    trigger_error('Un fichier indispensable à l\'exécution du script est manquant.', E_USER_ERROR);
?>

Pour la route

Quelques fonctions également utiles :

  • error_log() vous permet d'enregistrer un message dans l'historique de PHP, dans un fichier, ou de vous l'envoyer par mail ;

  • restore_error_handler() permet de réutiliser l'ancienne version de gestion des erreurs (qui peut être la fonction PHP par défaut, ou une autre fonction utilisateur) ;

  • user_error() est un alias de trigger_error(), question de goût ^^ ;

  • error_get_last() (PHP >= 5.2.0) renvoie un array contenant les informations à propos de la dernière erreur survenue.

Voilà, c'est fini ! ^^ J'espère que ce tuto vous a plu, et qu'il vous a permis de mieux comprendre la gestion des erreurs.

Exemple de certificat de réussite
Exemple de certificat de réussite