### Fin de script : exit

exit met immédiatement fin au script PHP courant et provoque l'envoi de la page telle qu'elle est au navigateur. exit n'est ni une instruction ni une fonction, mais une "construction du langage".

exit peut être employée telle que (ie sans parenthèse et sans paramètre), ou avec un paramètre qui peut être une chaîne de caractères ou un entier :

- si le paramètre transmis à exit est une chaîne, elle sera transmise au navigateur qui l'affichera;
- si le paramètre transmis à exit est un entier, cette valeur constituera le statut de sortie du script et elle ne sera pas affichée. Le statut de sortie peut être dans l'intervalle 0-255, le statut de sortie 255 est réservé par PHP et ne doit pas être utilisé. Le statut 0 est utilisé pour terminer le programme avec succès.

die est un alias de exit et peut être utilisé à sa place avec les même règles.

Exemple : fin de script
<!DOCTYPE html> <html lang="fr"> <head><title>Fin de script</title></head> <body> Cette ligne sera affichée car située avant exit <?php echo '<p>Traitement PHP ....</p>'; $s = date('s'); echo $s, '<hr>'; // une erreur se produit, arrêt du script if ($s % 2 == 0){ exit('Erreur dans le script. Fin anormale du traitement'); } exit(1); ?> Cette ligne ne sera pas affichée car située après exit </body> </html>

### Niveaux d'erreur

Quand une erreur se produit dans un script PHP celui-ci ne sera pas forcément arrêté. Si le niveau de l'erreur n'est pas défini comme fatal, un message d'erreur sera simplement émis par PHP. Suivant la configuration de PHP, les messages d'erreur sont envoyés à la sortie courante (ie affiché dans la page) ou stockés dans un fichier. Si l'erreur est une erreur fatale, l'exécution du script s'arrête.

Il y a 3 niveaux d'erreur dans PHP :

- une erreur notice est une erreur sans gravité pour le script, par exemple utiliser une variable qui n'a pas été définie. PHP utilisera ses mécanismes internes pour "corriger" l'erreur. Le script fonctionnera, mais les résultats ne seront peut être pas ceux attendus.
- une erreur warning n'arrête pas le script. C'est le cas par exemple d'une fonction appelée avec des mauvais arguments. Un message sera affiché.
- une erreur fatale est une erreur qui arrête le script. Le plus souvent ce sont des parse error : le code est syntaxiquement incorrect.

Par défaut, toutes les erreurs sauf notice, sont capturées et un message est affiché.

La fonction error_reporting() permet de définir, pour un script, les erreurs qui seront capturées et pour lesquelles un message sera affiché.

La fonction accepte comme argument une ou plusieurs constantes :

- E_ERROR : erreurs d'exécution graves provoquant un arrêt du script
- E_WARNING : erreurs d'exécution sans arrêt du script
- E_NOTICE : erreurs d'exécution faibles, comparables à des remarques
- E_CORE_ERROR : erreurs internes graves de PHP
- E_CORE_WARNING : erreurs internes de PHP sans arrêt du script
- E_COMPILE_ERROR : erreurs internes de compilation du Zend Engine
- E_COMPILE_WARNING : erreurs internes warning de compilation du Zend Engine
- E_USER_ERROR : cf E_ERROR, mais déclenchée par le développeur dans le code avec trigger_error
- E_USER_WARNING : cf E_WARNING, mais déclenchée par le développeur dans le code avec trigger_error
- E_USER_NOTICE : cf E_NOTICE, mais déclenchée par le développeur dans le code avec trigger_error
- E_STRICT : gestion des différences entre les versions de PHP
- E_RECOVERABLE_ERROR : cf E_ERROR si elles ne sont pas gérées par le script
- E_DEPRECATED : erreurs dûes à des instructions dépréciées de PHP (supprimées dans les versions futures)
- E_USER_DEPRECATED : cf E_DEPRECATED, mais déclenchée par le développeur dans le code avec trigger_error
- E_ALL : Toutes les erreurs

Par exemple pour afficher toutes les erreurs d'exécution on appellera la fonction de la façon suivante en utilisant l'opérateur de bit | :

    error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);

Pour afficher toutes les erreurs :

    error_reporting(E_ALL);

Dans la phase de développement, le recours à la dernière instruction est utile, car il permet en particulier de déceler l'utilisation de variables non définies, source d'erreurs parfois difficiles à déceler.

Pour supprimer tous les messages d'erreur (excépté les parse error qu'il n'est pas possible de supprimer), utilisez :
error_reporting(0);

L'utilisation de l'opérateur @ (arobase) placé devant une expression, ou une fonction qui renvoie une expression, supprime l'affichage de message en cas d'erreur dans l'instruction.

Exemple : utilisation de @
<!DOCTYPE html> <html lang="fr"> <head><title>Utilisation de @</title></head> <body> <?php echo 'Division par 0 avec message d\'erreur'; $resultat = 10 / 0; echo '<hr>Division par 0 sans message d\'erreur'; $resultat = @(10 / 0); ?> </body> </html>

### Gestionnaire d'erreurs

Nous pouvons définir notre propre gestionnaire d'erreurs avec la fonction set_error_handler(). Cette fonction nécessite comme argument le nom de notre fonction personnalisée de gestion d'erreurs. Par exemple :
set_error_handler('gererErreurs');

La fonction gererErreurs() recevra 5 paramètres, passés automatiquement par PHP :

- code d'erreur
- message d'erreur
- nom du fichier où se produit l'erreur
- numéro de ligne de l'erreur
- copie de la table des symboles en cours.

Pour remettre en place le gestionnaire d'erreurs initial, il faut utiliser la fonction restore_error_handler().

Exemple : gestionnaire d'erreurs
<!DOCTYPE html> <html lang="fr"> <head><title>Gestionnaire d'erreurs</title></head> <body> <?php error_reporting(E_ALL); // aucune erreur acceptée set_error_handler('gererErreurs'); echo '<p>Division par 0 avec message d\'erreur'; $resultat = 10 / 0; //------------------------------------------------------ function gererErreurs($num, $msg, $fichier, $lig, $symb) { echo '<p><font color="red">Une erreur s\'est produite : ', '<br>Numéro : ', $num, '<br>Message : ', $msg, '<br>Fichier : ', $fichier, '<br>Ligne : ', $lig; echo '<pre>Table des symboles : '; print_r($symb); exit; // fin du script } ?> </body> </html>

Notre fonction gererErreurs() affiche toutes les informations qu'il est possible de récupérer sur une erreur. Vous pouvez remarquer que l'affichage de la table des symboles, n'est pas ici d'une grande utilité car le script ne manipule par beaucoup d'éléments. Vous remarquerez aussi que le nom du fichier dans lequel se produit l'erreur est un nom complet, donnant des informations sur les répertoires. Ces informations peuvent être utilisées à des fins de piratage et ne devraient pas être affichées. Nous allons donc constituer un message d'erreur plus sybillin.

Exemple : gestionnaire d'erreurs
<!DOCTYPE html> <html lang="fr"> <head><title>Gestionnaire d'erreurs</title></head> <body> <?php error_reporting(E_ALL); // aucune erreur acceptée set_error_handler('gererErreurs'); echo '<p>Division par 0 avec message d\'erreur'; $resultat = 10 / 0; //------------------------------------------------------ function gererErreurs($num, $msg, $fichier, $lig, $symb) { echo '<p><font color="red">L\'erreur ',$num, ' (', $msg, ') s\'est produite dans ', basename($fichier), ' à la ligne ', $lig; exit; // fin du script } ?> </body> </html>

### Redirection des messages d'erreur

Par défaut les messages d'erreurs sont dirigés vers la sortie courante : la page et donc le navigateur.

La fonction error_log() permet de choisir une autre destination pour les messages d'erreurs, et d'en garder une trace. Elle accepte trois arguments : le message d'erreur, la destination du message, et optionnellement une adresse de destination :
error_log(message, destination [,adresse]);

- Si destination vaut 0, le message est envoyé dans le fichier d'erreur de PHP, défini dans la configuration de PHP avec l'option error_log.
- Si destination vaut 1, le message est envoyé à l'adresse e-mail donnée par l'argument adresse. Il faut que votre serveur dispose d'un serveur de mail pour réaliser correctement l'envoi.
- Si destination vaut 3, le message est ajouté à la fin du fichier dont le nom est donné par l'argument adresse. Le nom de fichier est un nom complet.

L'exemple suivant montre la redirection des messages d'erreur dans un fichier appelé erreurs.txt

Exemple : gestionnaire d'erreurs
<!DOCTYPE html> <html lang="fr"> <head><title>Gestionnaire d'erreurs</title></head> <body> <?php error_reporting(E_ALL); // toutes les erreurs sont capturées set_error_handler('gererErreurs'); echo '<hr>Division par 0'; $resultat = 10 / 0; function gererErreurs($num, $msg, $fichier, $lig, $symb) { // Message affiché dans la page echo '<p>Une erreur s\'est produite ...'; // message stocké $buffer = date('d/m/Y H:i:s') . " : erreur $num ($msg)" . " dans $fichier, ligne $lig\n"; error_log($buffer, 3, 'erreurs.txt'); exit; // fin du script } ?> </body> </html>

Après avoir exécuté le script une (ou plusieurs fois), vous devez avoir dans votre dossier de travail le fichier "erreurs.txt" contenant les messages d'erreurs envoyés.
Contenu de votre dossier de travail

Le dossier de travail contient déjà des sous-répertoires et fichiers de types divers qui sont préparés pour être utilisé tout au long de ce tutoriel