phpmaster | Gestion des erreurs en php

Les erreurs sont l'événement le plus courant auquel un développeur est confronté lors de la programmation. Les erreurs peuvent être classées comme syntaxiques, temporelles ou logiques: manquer le point-virgule à la fin d'une instruction est un exemple d'erreur de syntaxe; Essayer de se connecter à une base de données lorsque le serveur est en panne est un exemple d'erreur d'exécution; Fournir des données incorrectes à une variable est un exemple d'erreur logique. Pour aider à réduire le nombre d'erreurs dans votre code et pour atténuer leurs effets, une gestion des erreurs appropriée est essentielle dans votre application Web. Cet article est un cours intensif dans la gestion des erreurs de PHP. Vous découvrirez les niveaux de rapport d'erreur intégrés de PHP et comment gérer les erreurs avec des gestionnaires d'erreurs personnalisés et la manipulation des exceptions.

Les plats clés

• La gestion des erreurs PHP est cruciale pour maintenir l'intégrité et les fonctionnalités d'une application Web. Il aide à identifier et à résoudre les problèmes qui peuvent survenir lors de l'exécution du script, en améliorant l'expérience utilisateur en contrôlant ce qu'ils voient lorsqu'une erreur se produit.
• PHP propose plusieurs fonctions intégrées pour la gestion des erreurs, y compris les journalisations et les afficher. Il offre également une flexibilité pour personnaliser les stratégies de traitement des erreurs en enregistrant les gestionnaires d'erreurs et en utilisant des exceptions.
• La gestion des erreurs personnalisée dans PHP peut être réalisée à l'aide de fonctions set_error_handler () et set_exception_handler (). Ceux-ci permettent aux développeurs de définir des règles et des exceptions de gestion des erreurs personnalisées, qui peuvent être utiles pour les erreurs de journalisation ou les notifications d'erreur d'envoi.
• Les exceptions en PHP sont des événements qui se produisent lors de l'exécution du script, perturbant le flux normal des instructions. Ils peuvent être manipulés en utilisant Try, Catch et enfin des blocs. Si aucun bloc de capture n'est trouvé lorsqu'une exception est lancée, PHP affiche une erreur fatale et cessera d'exécuter le script.

Niveaux de rapport d'erreur PHP

Toutes les erreurs et avertissements doivent être enregistrés. Sur la base de la gravité d'une erreur, les notifications doivent être envoyées à d'autres systèmes / équipes. Pour que vous puissiez mieux évaluer sa gravité, PHP fournit plusieurs niveaux d'erreur intégrés pour décrire la nature d'une erreur. Chaque niveau est représenté par une valeur entière et nommé constante qui peut être utilisé par le programmeur. Le tableau ci-dessous est tiré de la documentation officielle PHP et montre certains des différents niveaux.

Les niveaux peuvent être masqués avec des opérateurs de bits pour les inclure ou les soustraire de la configuration de PHP. Par exemple, E_ALL | E_STRICT permet toutes les erreurs et avertissements avec l'ajout d'E_Strict (nécessaire dans les versions de PHP avant 5.4). PHP fournit quelques directives de configuration liées à la journalisation et à l'affichage des erreurs. Leurs valeurs sont généralement différentes selon que le système se trouve dans un développement ou un environnement de production. Ce tableau montre certaines des directives liées aux erreurs.

Les directives de configuration peuvent être définies soit dans php.ini, dans un fichier de configuration de serveur Web (fichier httpd.conf ou .htaccess), soit à l'exécution de votre script à l'aide de la fonction ini_set (). Lisez la documentation pour plus d'informations sur les directives et comment / où les définir.

Création de gestionnaires d'erreurs personnalisés

Il est également pratique de ne pas afficher les erreurs brutes à l'utilisateur final. Les erreurs affichées doivent être abstraites avec des messages d'erreur conviviaux et personnalisés. PHP fournit non seulement des fonctions intégrées pour la journalisation et l'affichage des erreurs, mais aussi pour les élever. Vous pouvez déclencher de manière pragmatique une erreur d'un niveau spécifique en utilisant Trigger_error (). Par exemple, ce code déclenche un avertissement e_user_notice si la valeur de $ test est supérieure à 1:

<span><span><?php
</span></span><span><span>$test = 5;
</span></span><span><span>if ($test > 1) {
</span></span><span>    <span>trigger_error('Value of $test must be 1 or less', E_USER_NOTICE);
</span></span><span><span>}</span></span>

Le déclenchement des erreurs avec Trigger_error () est utile lorsque vous avez une infrastructure de gestion des erreurs en place, vous permettant d'unifier la gestion des erreurs personnalisées et des erreurs et avertissements soulevés par PHP. Si vous souhaitez implémenter des stratégies de traitement des erreurs personnalisées telles que l'envoi d'un e-mail ou des erreurs d'enregistrement dans une base de données en fonction de leur gravité, vous devrez définir les gestionnaires d'erreurs personnalisés à l'aide de set_error_handler (). La fonction accepte deux arguments: une fonction de rappel ou une méthode statique qui sera invoquée lorsque l'erreur est augmentée, et éventuellement le niveau d'erreur de la fonction / méthode gère. La signature du rappel est:

handler(int $errno, string $errstr, string $errfile, int $errline, array $errcontext)

Jetons un coup d'œil à une fonction de gestionnaire d'erreur personnalisée. L'exemple ci-dessous enregistre les erreurs dans une base de données de table de base de données chaque fois que l'on est rencontré:

<span><span><?php
</span></span><span><span>$test = 5;
</span></span><span><span>if ($test > 1) {
</span></span><span>    <span>trigger_error('Value of $test must be 1 or less', E_USER_NOTICE);
</span></span><span><span>}</span></span>

Le extrait ci-dessus enregistre un gestionnaire d'erreurs qui fait ce qui suit: Lorsque des erreurs non mortelles se produisent, un enregistrement sera inséré dans la base de données au lieu d'afficher l'erreur et de le journaliser dans un fichier; Lorsqu'une erreur mortelle se produit, elle sera enregistrée dans la base de données et terminera votre script. Il existe cependant certaines limites aux gestionnaires d'erreurs personnalisés dont vous devez être conscient. Le gestionnaire d'erreurs contourne le comportement de gestion des erreurs de PHP, il ne peut donc pas gérer les erreurs qui peuvent survenir au sein de votre gestionnaire lui-même. Dans le cas où le serveur de base de données est en panne, par exemple, la fonction ci-dessus ne parviendrait pas à enregistrer le journal. En outre, le gestionnaire d'erreurs n'est pas en mesure d'attraper certaines erreurs internes, comme E_Core_error et E_Compile_error, ou E_Strict Errers dans le même fichier dans lequel le gestionnaire est défini car ces erreurs se produisent avant que le gestionnaire ait une chance d'être enregistré.

Traiter les erreurs en utilisant des exceptions

Aussi bon d'un cadre de gestion des erreurs que vous avez en place, il y aura toujours des problèmes au moment de l'exécution. Bien sûr, vous ne voulez pas que ces erreurs apparaissent dans le navigateur de l'utilisateur. C'est là que la gestion des exceptions entre dans l'image. Les exceptions vous permettent de gérer gracieusement les erreurs et les situations exceptionnelles. Les exceptions sont représentées en PHP par l'expétion de classe (ou l'une de ses sous-classes). Ils peuvent être élevés à l'aide de lancer et peuvent être capturés à l'aide d'un bloc Try / Catch. Vous pouvez étendre une exception pour créer des types d'exceptions personnalisés pour piéger des erreurs spécifiques. Le code qui peut déclencher une exception est placé dans le bloc d'essai, et le code pour gérer l'exception est placé dans le bloc de capture. Considérez l'extrait suivant:

handler(int $errno, string $errstr, string $errfile, int $errline, array $errcontext)

Si une exception est lancée par la méthode fictive getDataFromService (), elle sera prise dans le bloc de capture et un message sera affiché. Si getDataFromService () exécute avec succès, le flux passera sur le bloc de capture et continuera le reste du script. Toutes les exceptions qui sont lancées et non capturées généreront une erreur E_Fatal avec le message «Exception non approuvée». La classe d'exception propose six méthodes différentes pour accéder aux informations sur ce qui a causé le problème, comme le montre le tableau ci-dessous.

Création d'un gestionnaire d'exceptions personnalisés

PHP vous permettra de lancer n'importe quel objet comme s'il s'agissait d'une exception, mais en règle générale, l'exception devrait étendre la classe d'exception intégrée de PHP. En fonction du type de l'objet, vous pouvez gérer les exceptions différemment. La gestion des exceptions personnalisées peut effectuer des actions appropriées comme les messages d'erreur de journalisation dans le fichier, fournissant des détails exacts sur la ligne sur laquelle l'erreur s'est produite en examinant la pile d'appels, etc. Jetez un œil à cet exemple:

<span><span><?php
</span></span><span><span>$test = 5;
</span></span><span><span>if ($test > 1) {
</span></span><span>    <span>trigger_error('Value of $test must be 1 or less', E_USER_NOTICE);
</span></span><span><span>}</span></span>

Le code ci-dessus définit deux nouveaux types d'exceptions personnalisés, NameException et EmailException, qui peut être utilisé pour indiquer différentes erreurs. Ensuite, dans le bloc d'essai, le code vérifie si des valeurs ont été fournies pour les variables $ nom et $ e-mail. Si l'un ou l'autre est vide, l'exception appropriée est lancée à l'aide de lancer. Le bloc de capture correspondant est exécuté qui gère l'erreur.

RETOUR DES EXCEPTIONS

Les blocs d'essai / capture peuvent être imbriqués. Parfois, vous voudrez prendre une exception, regarder certaines de ses propriétés, puis la jeter à nouveau pour laisser un parent attraper le bloc de le gérer. Cela peut souvent être utile pour vérifier une condition d'erreur et décider si elle doit être fatale ou non. Cet exemple de code montre le retrait d'une exception:

handler(int $errno, string $errstr, string $errfile, int $errline, array $errcontext)

Handler des exceptions non revêtus

Semblable à la façon dont set_error_handler () vous permet de spécifier une fonction pour gérer les erreurs d'exécution, la fonction set_exception_handler () vous permet de gérer les exceptions qui font tout le long de la pile d'appels sans être attrapé par aucun bloc de capture. Par exemple, si une exception fait tout le long de votre pile, ce serait une bonne idée de le connecter dans un fichier journal. Vous pouvez créer une fonction de rappel et l'enregistrer avec set_exception_handler () comme indiqué dans l'exemple ci-dessous.

<span><span><?php
</span></span><span><span>function errorHandler($errno, $errstr, $errfile, $errline) {
</span></span><span>    <span>static $db;
</span></span><span>    <span>if (empty($db)) {
</span></span><span>        <span>$db = new PDO(DSN, DBUSER, DBPASS);
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>$query = "INSERT INTO errorlog (severity, message, filename, lineno, time) VALUES (?, ?, ?, ?, NOW())";
</span></span><span>    <span>$stmt = $db->prepare($query);
</span></span><span>
</span><span>    <span>switch ($errno) {
</span></span><span>        <span>case E_NOTICE:
</span></span><span>        <span>case E_USER_NOTICE:
</span></span><span>        <span>case E_DEPRECATED:
</span></span><span>        <span>case E_USER_DEPRECATED:
</span></span><span>        <span>case E_STRICT:
</span></span><span>            <span>$stmt->execute(array("NOTICE", $errstr, $errfile, $errline));
</span></span><span>            <span>break;
</span></span><span>
</span><span>        <span>case E_WARNING:
</span></span><span>        <span>case E_USER_WARNING:
</span></span><span>            <span>$stmt->execute(array("WARNING", $errstr, $errfile, $errline));
</span></span><span>            <span>break;
</span></span><span>
</span><span>        <span>case E_ERROR:
</span></span><span>        <span>case E_USER_ERROR:
</span></span><span>            <span>$stmt->execute(array("FATAL", $errstr, $errfile, $errline));
</span></span><span>            <span>exit("FATAL error <span><span>$errstr</span> at <span>$errfile</span>:<span>$errline</span>"</span>);
</span></span><span>
</span><span>        <span>default:
</span></span><span>            <span>exit("Unknown error at <span><span>$errfile</span>:<span>$errline</span>"</span>);
</span></span><span>    <span>}
</span></span><span><span>}
</span></span><span>
</span><span><span>set_error_handler("errorHandler");
</span></span><span>
</span><span><span>$test = 5;
</span></span><span><span>if ($test > 1) {
</span></span><span>   <span>trigger_error("Value of <span><span>$test</span> must be 1 or less"</span>, E_USER_NOTICE);
</span></span><span><span>}</span></span>

Résumé

PHP offre une variété de fonctions intégrées pour gérer les conditions d'erreur, y compris les journalisations et les afficher. Il vous offre également la flexibilité pour personnaliser vos stratégies de gestion des erreurs en enregistrant les gestionnaires d'erreurs et en utilisant des exceptions. Les erreurs sont une réalité, mais j'espère que les informations que j'ai présentées dans cet article vous aideront à les gérer plus gracieusement. Image via Ilya Andriyanov / Shutterstock

Les questions fréquemment posées (FAQ) sur la gestion des erreurs dans PHP

Quelle est l'importance de la gestion des erreurs dans PHP?

La gestion des erreurs en PHP est cruciale pour maintenir l'intégrité et la fonctionnalité d'une application Web. Il aide les développeurs à identifier et à résoudre les problèmes qui peuvent survenir lors de l'exécution d'un script. Sans gestion des erreurs appropriée, un problème mineur peut causer des problèmes importants, tels que le fait de placer l'application ou d'exposer des informations sensibles aux utilisateurs. Il améliore également l'expérience utilisateur car il permet aux développeurs de contrôler ce que l'utilisateur voit lorsqu'une erreur se produit, plutôt que d'afficher des messages d'erreur déroutants.

Comment PHP gère-t-il les erreurs par défaut?

Par défaut, PHP envoie un rapport d'erreur au journal d'erreur du serveur et affiche un message d'erreur à l'écran. Ce comportement n'est pas idéal pour un site Web en direct car il peut révéler des informations sensibles à l'utilisateur. Par conséquent, il est recommandé de modifier les paramètres de gestion des erreurs par défaut pour un site Web en direct.

Quels sont les différents types d'erreurs dans PHP?

PHP classe les erreurs en plusieurs types, y compris les erreurs mortelles, les avertissements, les erreurs d'analyse et les avis. Les erreurs fatales sont des erreurs critiques, comme appeler une fonction inexistante ou écrire dans un fichier qui n'est pas écrivable. Les avertissements sont des erreurs non mortelles qui permettent au script de continuer à fonctionner. Les erreurs d'analyse se produisent lorsqu'il y a une erreur de syntaxe dans le script. Les avis sont des erreurs mineures ou des erreurs possibles que PHP rencontre lors de l'exécution d'un script.

Comment puis-je personnaliser la gestion des erreurs dans PHP?

PHP fournit plusieurs fonctions pour personnaliser la gestion des erreurs, telles que set_error_handler () et set_exception_handler (). Ces fonctions vous permettent de définir des règles et des exceptions de gestion des erreurs personnalisées. Vous pouvez spécifier une fonction personnalisée pour gérer les erreurs, qui peuvent être utiles pour la journalisation des erreurs ou l'envoi de notifications d'erreur.

Quelle est une exception dans PHP?

Une exception est un événement qui se produit lors de l'exécution d'un script qui perturbe le flux normal des instructions du script. Lorsqu'une exception est lancée, PHP cessera d'exécuter le script et commencera à chercher un bloc de capture pour gérer l'exception. Si aucun bloc de capture n'est trouvé, PHP affichera une erreur fatale et cessera d'exécuter le script.

Comment puis-je gérer les exceptions dans PHP?

PHP fournit l'essai, la capture et enfin des blocs pour gérer les exceptions. Le bloc d'essai contient le code qui peut lancer une exception. Le bloc Catch contient le code pour gérer l'exception. Le bloc enfin contient le code qui sera exécuté, que ce soit une exception ou non.

Quelle est la différence entre les erreurs et les exceptions dans PHP?

La principale différence entre les erreurs et les exceptions dans PHP est la façon dont ils sont gérés. Les erreurs sont gérées par le moteur PHP et peuvent être contrôlées à l'aide des paramètres de rapport d'erreur et des gestionnaires d'erreurs personnalisés. Les exceptions, en revanche, sont gérées par le script et peuvent être contrôlées à l'aide de Try, Catch et enfin des blocs.

Comment puis-je désactiver les rapports d'erreurs dans PHP?

Vous pouvez désactiver les rapports d'erreur en PHP en utilisant la fonction error_reportting () avec 0 comme argument. Cependant, la désactivation des rapports d'erreurs n'est pas recommandée pour un site Web en direct, car il peut rendre difficile l'identification et résoudre les problèmes.

Quel est le rôle de l'opérateur @ dans la gestion des erreurs PHP?

L'opérateur @ dans PHP est utilisé pour supprimer les messages d'erreur. Lorsqu'il est admis à une expression en PHP, tous les messages d'erreur qui pourraient être générés par cette expression seront ignorés.

Comment puis-je enregistrer les erreurs dans PHP?

PHP Fournit la fonction error_log () pour envoyer un message d'erreur au journal d'erreur du serveur ou à un fichier spécifié. Cette fonction peut être utile pour suivre les erreurs et le débogage. Vous pouvez également configurer PHP pour enregistrer toutes les erreurs en modifiant la directive log_errors dans le fichier php.ini.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!