Vous vous apprêtez à lire un tutoriel rédigé par un membre de ce site. Malgré tout le soin que ce membre a pu apporter au tutoriel, nous ne pouvons pas garantir que les informations contenues sur cette page sont exactes à 100%. Merci de garder cela en tête lorsque vous lirez cette page ;o)
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é, d'esthétique aussi
.
Dans ce tuto, je vais vous expliquer comment gérer vous-mêmes l'affichage de ces erreurs, et comment les personnaliser grâce aux
fonctions d'erreur mises à notre disposition par PHP.
Il existe une méthode très simple, mais très efficace pour éviter l'affichage des erreurs, c'est de passer 0 en argument à la fonction
error_reporting(), qui sert à indiquer le niveau de rapport d'erreur.
Exemple :
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12 | <?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 1 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 :
Code : PHP1
2
3
4
5 | <?php
if(!@include '/non-existing'){
echo 'Le fichier n\'existe pas!';
}
?>
|
Cette solution est efficace, mais le visiteur ne comprendra pas nécessairement pourquoi son action n'a pas été effectuée correctement, et c'est là que la fonction
set_error_handler() intervient.
set_error_handler() va en fait ignorer le rapport d'erreur 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édiaEn 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 pour son utilisation comme fonction de callback est différente.
- Les fonctions "simples", j'entends par là les fonctions que M@teo21 vous apprend à faire dans ses tutos.
Dans ce cas, on passe le nom de la fonction comme une chaîne de caractères.
Exemple :
Code : PHP1
2
3 | <?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.
Exemple :
Code : PHP1
2
3
4
5
6 | <?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 : l'une étant la programmation fonctionnelle (comme enseignée dans les cours de M@teo21) et l'autre étant la POO. Je ne vais pas rentrer dans les détails ici mais sachez qu'en POO, les fonctions sont réparties en 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 :
Code : PHP1
2
3 | <?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 :
Code : PHP1
2
3 | <?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 le nom de la méthode.
Exemple :
Code : PHP1
2
3
4 | <?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 donc en modifiant la référence, on modifiera également la variable.
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
- la ligne dans le fichier
- le contexte de l'erreur.
Je ne me servirai pas du contexte de l'erreur, mais libre à vous d'aller voir la doc pour plus d'informations sur ce paramètre.
Exemple de fonction :
Code : PHP1
2
3
4
5
6 | <?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>';
}
?>
|
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'erreur à l'aide de
trigger_error(). Ainsi, nous pouvons définir des comportements différents de la fonction suivant le type d'erreur.
Exemple :
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 | <?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ér0, par exemple, avec des liens pour aller à la page suivante / précédente, ou encore ajouter les autres types 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 2
e 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
.
Comme je vous l'avais annoncé dans la partie précédente, la fonction qui déclenche les erreurs c'est :
trigger_error() (qui se traduit d'ailleurs par "déclencher erreur"
) ; celle-ci est très simple d'utilisation, vous allez voir.
trigger_error() a deux 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 ; dans le cas contraire, vous aurez droit à un
warning.
Maintenant que vous savez tout, démonstration
:
Code : PHP 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42 | <?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;
}
}
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);
?>
|
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() (PHP5 >= 5.2.0) renvoie un array contenant les informations à propos de la dernière erreur survenue.
Tutoriels
Communauté
Mon compte
Recherche
Livre d'or
Publicité
287 Zéros connectés |
8 requêtes |
0.033s (0.0183s)
