This article introduces the content of PHP7 error exception level, which has certain reference value. Now I share it with everyone. Friends in need can refer to it

PHP 7 error exception level

Exploring the Exception Hierarchy of PHP 7

In the past, it was almost impossible to handle fatal errors in PHP. Fatal errors simply terminate script execution without calling the set_error_hander() error handler.

In PHP 7, when fatal or recoverable errors (E_ERROR and E_RECOVERABLE_ERROR) occur, the exception will be caught instead of aborting the script. Under certain circumstances, there are still fatal errors, such as insufficient memory, and the script will be terminated immediately as before. Uncaught exceptions are still fatal errors in PHP 7. This means that an uncaught exception in PHP 5.x is still a fatal error in PHP 7.

Note that errors such as warnings or notifications remain unchanged in PHP 7, only fatal errors or recoverable errors will throw exceptions.

Throwing of fatal or recoverable errors does not extend from the Exception class. This separation is to prevent existing PHP 5.x code from calling the terminate routine if it receives an error exception. Exceptions thrown by fatal or recoverable errors will instantiate a new exception class: Error. Like other exception classes, the caught Error class will be processed after the last program block is executed.

Compared with PHP 7 alpha-2, the exception class hierarchy of PHP 7 is different. The thrown fatal and recoverable errors will be instantiated in the EngineException class, and the EnginException class Does not inherit from Exception. Both Exception and EngineException inherit from BaseException.

Throwable

In order to combine these two exception branches, both Exception and Error implement a new interface, Throwable.

The new exception hierarchy in PHP 7 is as follows:

Throwable //（接口）
    |- Exception implements Throwable
        |- ...
    |- Error implements Throwable
        |- TypeError extends Error 
        |- ParseError extends Error // 编译时错误
        |- ArithmeticError extends Error
            |- pisionByZeroError extends ArithmeticError
        |- AssertionError extends Error

If you define the Throwable interface in PHP 7, it should be similar to the following code.

interface Throwable{
    public function getMessage(): string;
    public function getCode(): int;
    public function getFile(): string;
    public function getLine(): int;
    public function getTrace(): array;
    public function getTraceAsString(): string;
    public function getPrevious(): Throwable;
    public function __toString(): string;}

This interface should be familiar. Throwable-specific methods are the same as Exception's. The only difference is that Throwable::getPrevious() will return a Throwable Exception and the constructor of the Error class will receive an instance of Throwable as the previous exception.

Throwable can be used to catch exceptions or error objects in try/catch blocks (more exception types may be caught in the future). Remember, it is recommended here to capture more specific exception classes and take appropriate handling measures. However, in some cases, it is necessary to catch exceptions broadly (such as logging or the framework's error handling). In PHP 7, these exception catching blocks are more suitable to use Throwable instead of Exception.

try {    // Code that may throw an Exception or Error.} catch (Throwable $t) {    // Handle exception}

Custom classes cannot implement Throwable plug-ins, partly due to predictability and consistency: only instantiating the Excetion and Error classes can throw exceptions. In addition, the exception carries information about the object that was created on the stack. Custom classes do not automatically have parameters that hold information.

Throwable can be extended to create package-specific interfaces or add additional methods. Only classes that inherit Exception or Error can implement plug-ins that extend Throwable.

interface MyPackageThrowable extends Throwable {}class MyPackageException extends Exception implements MyPackageThrowable {}throw new MyPackageException();

Error

In PHP 5.0, all errors are fatal errors or recoverable fatal errors, while in PHP 7, all errors are thrown. Like other exceptions, Error objects can be caught through try/catch blocks.

$var = 1;try {
    $var->method(); // Throws an Error object in PHP 7.} catch (Error $e) {    // Handle error}

Usually, previous fatal errors will throw an instantiation of the Error base class, but some errors will throw more specific Error subclasses: TypeError, ParseError, and AssertionError.

TypeError (type error)

TypeError instantiation is thrown by the actual parameters and formal parameters. When the function is called, the formal parameters and actual parameter types declared when calling the function are inconsistent (incoming parameters and methods) The defined parameter types are inconsistent) will throw a TypeError instance.

function add(int $left, int $right){
    return $left + $right;
}try {    $value = add('left', 'right');
} catch (TypeError $e) {    echo $e->getMessage(), "\n";
}

Resulted output:

Argument 1 passed to add() must be of the type integer, string given

ParseError (parse error)

included/required file, or when the code in eval() contains a syntax error, ParseError will be Throw.

try {    require 'file-with-parse-error.php';
} catch (ParseError $e) {    echo $e->getMessage(), "\n";
}

ArithmeticError (arithmetic error)

There are two situations where ArithmeticError is thrown: negative displacement, or using PHP_INT_MIN as the numerator and -1 as the denominator to call intp() (PHP_INI_MIN / -1 The return value is a floating point type).

try {    $value = 1 << -1;
} catch (ArithmeticError $e) {    echo $e->getMessage(), "\n";
}

pisionByZeroError (denominator is zero)

Using intp() or remainder (%) when the denominator is zero will throw a pisionByZeroError error. Note that division by zero only causes a warning and evaluates to NaN.

try {    $value = 1 % 0;
} catch (pisionByZeroError $e) {    echo $e->getMessage(), "\n";
}

AssertionError (Assertion)

When the conditions set by assert() are not met, an AssertionError error will be thrown.

ini_set('zend.assertions', 1);
ini_set('assert.exception', 1);$test = 1;

assert($test === 0);

The conditions set by assert() are not met, an AssertionError is thrown, and assert.exception = 1, the exception output is as follows:

Fatal error: Uncaught AssertionError: assert($test === 0)

assert() is only executed and will only throw an AssertionError if assertions are enabled and set to throw exceptions with ini settings zend.assertions = 1 and assert.exception = 1.

使用 Error

用户可以创建自己的 Error 类，作为 Error 基类的拓展。这可能带来重要的问题：什么场合下应该抛出一个 Exception 类的子类实例，什么场合下又应该抛出 Error 类的子类实例？

由于错误对象不应当在程序运行中处理，捕获错误对象应当是少见的。通常而言，错误对象应当捕获并记录之，执行必要的清理，并给用户展示错误信息。

编写兼容 PHP 5.x 和 7 Exceptions 类的代码

在 PHP 5.x 和 7 使用相同的代码捕获异常，可以实用多重捕获代码块，首先捕获 Throwable，之后时 Exception。一旦不需要维护 PHP 5.x 的系统，代码块可以立刻被清理掉。

try {    // Code that may throw an Exception or Error.} catch (Throwable $t) {    // Executed only in PHP 7, will not match in PHP 5.x} catch (Exception $e) {    // Executed only in PHP 5.x, will not be reached in PHP 7}

英文原文: trowski.com/2015

本文虽拙，却也系作者劳动，转载还请保留本文链接: http://cyleft.com/?p=721

相关推荐：

php错误级别详解

PHP错误与异常调试视频教程资源分享

The above is the detailed content of PHP 7 error exception level. For more information, please follow other related articles on the PHP Chinese website!