Detailed explanation of PHP's global error handling_php skills

Purpose of this article

PHP’s global 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. It is easier for developers to enter wrong words, causing fatal errors and eventually 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 conditions

Under normal circumstances, PHP will output fatal errors directly, and output the source of the error (file address, line number) and reason, etc. In this way, developers can easily locate the problem.

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 to help quickly locate question.

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 error output level. 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

By default, 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 executed, that is, when an error occurs, the error message will still be output, so the error level needs to be set to 0 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). Here is an example of using a custom error handling function:

<&#63;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 = 'Notice';
      break;
    case E_WARNING:
    case E_USER_WARNING:
      $error_type = 'Warning';
      break;
    case E_ERROR:
    case E_USER_ERROR:
      $error_type = 'Fatal Error';
      $EXIT = TRUE;
      break;
    default:
      $error_type = 'Unknown';
      $EXIT = TRUE;
      break;
  }
  printf ("%s: %s in %s on line %d\n", $error_type, $error_message, $file, $line);
 
  if ($EXIT) {
    die();
  }
}
set_error_handler ('error_handler');
 
//new NonExist();
echo $novar;
echo 3/0;
trigger_error ('Trigger a fatal error', E_USER_ERROR);
new NonExist();
&#63;>

Executing this script will get the following output:

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

Warning: Division 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 was not caught by the custom error handling function.

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