Detailed explanation of global error handling in php

php has its own try{throw{}}catch{} exception/error catching system, which is difficult to use in a production environment; in a production environment, we generally require that once an exception/error occurs, php immediately ends the script and displays it to the visitor The controller outputs an error message and sends a message to the administrator through Custom function

Purpose of this article

Global of PHP Error handling is very useful when developing projects. It can help developers quickly locate some problems and improve work efficiency. By default, global errors will be output directly, but a framework library recently used during development has set global error handling, resulting in many error messages not being output, and it is time-consuming to locate problems. Therefore, I studied the implementation of this library and found that it sets error_reporting and set_error_handler, causing this phenomenon. Now record the usage of these two functions as a memo.

Background

PHP does not have type detection, making it easier for developers to enter wrong words, causing fatal errors and ultimately causing the script to stop executing. If you don't get any error message at this time, it will be a very painful thing. You have to start debugging from the first line of code in the script, and continue to print or echo through thousands of lines of code until you locate the misspelled word. Then, you have to go back and delete all the previously added prints or echoes. This is an extremely boring job.

General situation

Under normal circumstances, PHP will output the fatal error directly, and output the source of the error (file address, line number) and reason, etc., so , developers can easily locate problems.

But sometimes, this information may not be output due to php.ini settings or third-party framework configuration issues. At this time, you must learn to set relevant parameters yourself and output these error messages. Help locate problems quickly.

error_reporting

error_reporting is a php global configuration parameter in php.ini. Used to configure the error output level. The parameter is a bit, which can be used to set the level of error output. The following is the information copied from php.ini:

; error_reporting is a bit-field. Or each number up to get desired error
; reporting level
; E_ALL - All errors and warnings (doesn't include E_STRICT)
; E_ERROR - fatal run-time errors
; E_RECOVERABLE_ERROR - almost fatal run-time errors
; E_WARNING - run-time warnings (non-fatal errors)
; E_PARSE - compile-time parse errors
; E_NOTICE - run-time notices (these are warnings which often result
; from a bug in your code, but it's possible that it was
; intentional (e.g., using an uninitialized variable and
; relying on the fact it's automatically initialized to an
; empty string)
; E_STRICT - run-time notices, enable to have PHP suggest changes
; to your code which will ensure the best interoperability
; and forward compatibility of your code
; E_CORE_ERROR - fatal errors that occur during PHP's initial startup
; E_CORE_WARNING - warnings (non-fatal errors) that occur during PHP's
; initial startup
; E_COMPILE_ERROR - fatal compile-time errors
; E_COMPILE_WARNING - compile-time warnings (non-fatal errors)
; E_USER_ERROR - user-generated error message
; E_USER_WARNING - user-generated warning message
; E_USER_NOTICE - user-generated notice message
;
; Examples:
;
; - Show all errors, except for notices and coding standards warnings
;
;error_reporting = E_ALL & ~E_NOTICE
;
; - Show all errors, except for notices
;
;error_reporting = E_ALL & ~E_NOTICE | E_STRICT
;
; - Show only errors
;
;error_reporting = E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ERROR|E_CORE_ERROR
;
; - Show all errors except for notices and coding standards warnings
;
error_reporting = E_ALL & ~E_NOTICE

Default In this case, php will output all error messages except notice. Similarly, the PHP standard function provides the function error_reporting(int $level) with the same name, which is used to complete the same function in PHP scripts. This will not affect other programs. It is worth noting that when $level is 0, error output is turned off, that is, no errors will be output.

set_error_handler

php's default error handling is to output the message. However, sometimes you need to define some other operations, in which case you need to customize the error handling function. PHP provides the built-in function set_error_handler to help us register our own error handling functions. The function prototype is as follows:

mixed set_error_handler ( callback $error_handler [, int $error_types = E_ALL | E_STRICT ] )

It is worth noting that even if the error handling function is registered, the default behavior will still be When executing, that is, when an error occurs, the error message will still be output, so you need to set the error level to 0 explicitly in the program, and then register your own error handling function. This approach is especially important in a production environment, because even if something goes wrong, sensitive internal error information will not be exposed to potentially malicious users. It is also important to point out that custom error handling functions cannot handle fatal errors (such as compilation errors). The following is an example of using a custom error handling function:

<?php
error_reporting (0);
function error_handler ($error_level, $error_message, $file, $line) {
  $EXIT = FALSE;
  switch ($error_level) {
    case E_NOTICE:
    case E_USER_NOTICE:
      $error_type = &#39;Notice&#39;;
      break;
    case E_WARNING:
    case E_USER_WARNING:
      $error_type = &#39;Warning&#39;;
      break;
    case E_ERROR:
    case E_USER_ERROR:
      $error_type = &#39;Fatal Error&#39;;
      $EXIT = TRUE;
      break;
    default:
      $error_type = &#39;Unknown&#39;;
      $EXIT = TRUE;
      break;
  }
  printf ("%s: %s in %s on line %d\n", $error_type, $error_message, $file, $line);
 
  if ($EXIT) {
    die();
  }
}
set_error_handler (&#39;error_handler&#39;);
 
//new NonExist();
echo $novar;
echo 3/0;
trigger_error (&#39;Trigger a fatal error&#39;, E_USER_ERROR);
new NonExist();
?>

Execute this script to get the following output:

Notice: Undefined variable: novar in /your/php_demo_file.php on line 40

Warning: pision by zero in /your/php_demo_file.php on line 41

Fatal Error: Trigger a fatal error in /your/php_demo_file.php on line 42

As you can see, the final "new NoExistClass()" exception, Not caught by custom error handling functions.

Finally, by the way, set_exception_handlerRegister the top-level exception handling. In web applications, you can set it and then jump to the error handling page uniformly.

The above is the detailed content of Detailed explanation of global error handling in php. For more information, please follow other related articles on the PHP Chinese website!