Résumé de l'utilisation de la fonction set error handler() 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 renverra l'ancien gestionnaire d'erreurs, si elle échoue, elle renverra null

La fonction set_error_handler() définit la 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.

Regardons quelques exemples.

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 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. . . .

L'utilisation de set_error_handler est la suivante :

Le code est le suivant :

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

Nous utilisons error_reporting(); Le message d'erreur que vous voyez comprend trois parties, le message d'erreur, l'adresse absolue du fichier d'erreur et le nombre de lignes 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 comme suit :

int register_shutdown_function ( string $func )

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

1. Cela ne rendra pas le fichier absolu. Le chemin est 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 le faire. considérer des choses comme 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.

Bon, 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 vous présenter séparément la fonction PHP set_error_handler()

définition et utilisation

set_error_handler() Paramètres de fonction 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.

Grammaire

set_error_handler(error_function,error_types)

参数 描述

error_function 必需。规定发生错误时运行的函数。
error_types 可选。规定在哪个错误报告级别会显示用户定义的错误。默认是 "E_ALL"。

提示和注释

提示：如果使用了该函数，会完全绕过标准的 PHP 错误处理函数，如果必要，用户定义的错误处理程序必须终止 (die() ) 脚本。

注释：如果在脚本执行前发生错误，由于在那时自定义程序还没有注册，因此就不会用到这个自定义错误处理程序。

例子

<?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

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!