Résumé de l'utilisation de la fonction de gestion d'erreurs définie en PHP

La fonction set_error_handler() définit une fonction de gestion des erreurs définie par l'utilisateur. Cette fonction est utilisée pour créer la propre méthode de gestion des erreurs de l'utilisateur pendant l'exécution. Cette fonction renvoie l'ancien gestionnaire d'erreurs, ou null en cas d'échec.

Regardez quelques exemples ci-dessous.

set_error_handler()

PHP fournit la fonction set_error_handler() d'un handle de gestion d'erreur personnalisé depuis la version 4.1.0, mais très peu de rédacteurs de scripts le savent. La fonction set_error_handler peut empêcher la fuite des chemins d'erreur et a bien sûr d'autres fonctions.

1. Peut être utilisé pour bloquer les erreurs. Si une erreur se produit, certaines informations seront exposées aux utilisateurs et il est très probable qu’elles deviennent un outil permettant aux pirates informatiques d’attaquer votre site Web. Deuxièmement, cela donne aux utilisateurs l’impression que votre niveau est très bas.

2. Vous pouvez noter les informations d'erreur et découvrir à temps certains problèmes dans l'environnement de production.

3. Le traitement correspondant peut être effectué lorsqu'une erreur se produit, un saut vers une page d'erreur prédéfinie peut être affiché pour offrir une meilleure expérience utilisateur.

4. Il peut être utilisé comme outil de débogage. Parfois, vous devez déboguer quelque chose dans l'environnement de production, mais vous ne voulez pas affecter les utilisateurs qui l'utilisent.

5. . . .

La méthode d'utilisation de set_error_handler est la suivante :

view sourceprint?1 string set_error_handler ( callback error_handler [, int error_types])

Le message d'erreur que nous voyons en utilisant error_reporting(); comprend trois parties, le message d'erreur, l'adresse absolue du fichier d'erreur, et la ligne où l'erreur s'est produite. En fait, il existe un autre type d’erreur. Array ( [type] => 1 [message] => Appel à une méthode non définie SomeClass::somemedthod() [file] => /home/zhangy/www/aaaa/stasdf.php [line] => 67 ), il est préférable de ne pas exposer le chemin absolu de la page aux autres, sinon cela donnera à certaines personnes l'occasion de se plaindre. Afin d'éviter cela, de nombreuses personnes utiliseront ini_set("display_errors",0); le message d'erreur. Ce n'est pas pratique. Et si nous voulons lire les informations ? Dois-je changer le code à chaque fois que je le vérifie, ou modifier la configuration d'Apache et le redémarrer ?

PHP a la fonction set_error_handler pour résoudre ce problème

L'utilisation est la suivante :

set_error_handler mixte ( rappel $error_handler [, int $error_types = E_ALL | E_STRICT ] )

la fonction php register_shutdown_function peut également résoudre ce problème

L'utilisation est la suivante :

int register_shutdown_function ( string $func )

Personnellement, je pense qu'il y a au moins trois avantages à définir vous-même la fonction d'erreur,

1 Le chemin absolu du fichier. ne sera pas affiché, ce qui est plus sûr

2 Même si un message d'erreur apparaît, nous pouvons traiter le message d'erreur afin que les utilisateurs ne puissent pas voir des erreurs fatales. L'expérience utilisateur devrait être meilleure

3. Une fois le projet lancé, il faut parfois encore aider les utilisateurs à résoudre des problèmes. À ce stade, il est inévitable de modifier le code, mais nous devons aussi le faire. signaler les messages d'erreur, et cela ne peut pas être vu par les utilisateurs pour le moment, c'est très cool d'utiliser une fonction comme set_error_handler.

J'ai fait un petit test

<?php
 error_reporting(0);
register_shutdown_function(&#39;error_alert&#39;);
 function error_alert()
 {
 if(is_null($e = error_get_last()) === false)
 {
 set_error_handler(&#39;errorHandler&#39;);
 if($e[&#39;type&#39;] == 1){
 trigger_error("fatal error", E_USER_ERROR);
 }elseif($e[&#39;type&#39;] == 8){
 trigger_error("notice", E_USER_NOTICE);
 }elseif($e[&#39;type&#39;] == 2){
 trigger_error("warning", E_USER_WARNING);
 }else{
 trigger_error("other", E_USER_OTHER);
 }
 }else{
 echo "no error";
 }
 }
 set_error_handler(&#39;errorHandler&#39;);
function errorHandler($errno, $errstr, $errfile, $errline,$errcontext)
 {
 switch ($errno) {
 case E_USER_ERROR:
 echo "<b>My ERROR</b> [$errno] $errstr<br />n";
 echo " Fatal error on line $errline in file $errfile";
 echo ", PHP " . PHP_VERSION . " (" . PHP_OS . ")<br />n";
 break;
 case E_USER_WARNING:
 echo "<b>My WARNING</b> [$errno] $errstr<br />n";
 echo " warning on line $errline in file $errfile";
 echo ", PHP " . PHP_VERSION . " (" . PHP_OS . ")<br />n";
 break;
 case E_USER_NOTICE:
 echo "<b>My NOTICE</b> [$errno] $errstr<br />n";
 echo " notice on line $errline in file $errfile";
 echo ", PHP " . PHP_VERSION . " (" . PHP_OS . ")<br />n";
 break;
 default:
 echo "Unknown error type: [$errno] $errstr<br />n";
 echo " warning on line $errline in file $errfile";
 echo ", PHP " . PHP_VERSION . " (" . PHP_OS . ")<br />n";
 break;
 }
 return true;
 }
class SomeClass {
 public function someMethod() {
 }
 }
SomeClass::someMedthod();
$a="asdf";
 foreach($a as $d){
 echo $d;
 }
 ?>

Nous utilisons maintenant une gestion des erreurs personnalisée pour filtrer le chemin réel. Supposons qu'il existe une variable $admin, que nous utilisons pour déterminer si le visiteur est un administrateur (cette détermination peut être effectuée par IP ou par ID d'utilisateur connecté)

//admin est l'identité du Détermination de l'administrateur, vrai est l'administrateur.
//La fonction de gestion des erreurs personnalisée doit avoir ces quatre variables d'entrée $errno, $errstr, $errfile, $errline, sinon elle sera invalide.

function my_error_handler($errno,$errstr,$errfile,$errline) 
{ 
  //如果不是管理员就过滤实际路径 
  if(!admin) 
  { 
    $errfile=str_replace(getcwd(),"",$errfile); 
    $errstr=str_replace(getcwd(),"",$errstr); 
  } 
  switch($errno) 
  { 
    case E_ERROR: 
    echo "ERROR: [ID $errno] $errstr (Line: $errline of $errfile) n"; 
    echo "程序已经停止运行，请联系管理员。"; 
    //遇到Error级错误时退出脚本 
    exit; 
    break; 
    case E_WARNING: 
    echo "WARNING: [ID $errno] $errstr (Line: $errline of $errfile) n"; 
    break; 
    default: 
    //不显示Notice级的错误 
    break; 
  } 
}

De cette façon, vous avez personnalisé une fonction de gestion des erreurs, alors comment confier la gestion des erreurs à cette fonction personnalisée ?

// 应用到类 
set_error_handler(array(&$this,"appError")); 
//示例的做法 
set_error_handler("my_error_handler");

si simple, de cette façon, la contradiction entre la sécurité et la commodité du débogage peut être bien résolue. Et vous pouvez également réfléchir à rendre le message d’erreur plus beau pour qu’il corresponde au style du site Web.

Dans l'exemple ci-dessus, j'ai désactivé le message d'erreur et utilisé ma propre fonction pour gérer l'erreur. La page ci-dessus signalera une erreur fatale. Nous pouvons utiliser errorHandler pour signaler le message d'erreur. et le traitement.

Bien, pour résumer, voici les trois utilisations de set_error_handler :

Code PHP

class CallbackClass {
 function CallbackFunction() {
 // refers to $this
 }
  
function StaticFunction() {
 // doesn't refer to $this
 }
 }
  
function NonClassFunction($errno, $errstr, $errfile, $errline) {
 }
 // 三种方法如下:
  
 set_error_handler(‘NonClassFunction'); // 直接转到一个普通的函数 NonClassFunction
 set_error_handler(array(‘CallbackClass', ‘StaticFunction')); // 转到 CallbackClass 类下的静方法 StaticFunction
 $o =& new CallbackClass();
 set_error_handler(array($o, ‘CallbackFunction')); // 转到类的构造函数，其实本质上跟下面的第四条一样。
. $o = new CallbackClass();
// The following may also prove useful
class CallbackClass {
 function CallbackClass() {
 set_error_handler(array(&$this, ‘CallbackFunction')); // the & is important
 }
function CallbackFunction() {
 // refers to $this
 }
 }

Laissez-moi prendre un peu de temps pour le présenter à vous individuellement. Présentation de la définition et de l'utilisation de la fonction PHP set_error_handler()

la fonction set_error_handler() définit une fonction de gestion des erreurs définie par l'utilisateur.

Cette fonction est utilisée pour créer la propre méthode de gestion des erreurs de l'utilisateur pendant l'exécution.

Cette fonction renvoie l'ancien gestionnaire d'erreurs, ou null en cas d'échec.

Syntaxe

set_error_handler(error_function,error_types)

Description du paramètre

error_function Obligatoire. Spécifie la fonction à exécuter lorsqu'une erreur se produit.
error_types facultatif. Spécifie à quel niveau de rapport d'erreurs les erreurs définies par l'utilisateur sont affichées. La valeur par défaut est "E_ALL".

Conseils et notes

Astuce : Si cette fonction est utilisée, la fonction standard de gestion des erreurs PHP sera complètement contournée. Si nécessaire, le gestionnaire d'erreurs défini par l'utilisateur doit se terminer (die()). scénario.

Remarque : si une erreur se produit avant l'exécution du script, le gestionnaire d'erreurs personnalisé ne sera pas utilisé car le programme personnalisé n'a pas été enregistré à ce moment-là.

Exemple

<?php
//error handler function
function customError($errno, $errstr, $errfile, $errline)
 { 
 echo "<b>Custom error:</b> [$errno] $errstr<br />";
 echo " Error on line $errline in $errfile<br />";
 echo "Ending Script";
 die();
 }
//set error handler
set_error_handler("customError");
$test=2;
//trigger error
if ($test>1)
 {
 trigger_error("A custom error has been triggered");
 }
?>

输出：

Custom error: [1024] A custom error has been triggered
Error on line 19 in C:/webfolder/test.php
Ending Script

更多PHP中set error handler函数用法小结相关文章请关注PHP中文网！