PHP的异常和错误处理，PHP错误处理

PHP的异常和错误处理，PHP错误处理

1.1 PHP的异常处理机制

在语言级别上，通常具有许多错误处理模式，但这些处理模式往往简历在约定俗成的基础上，即这些错误是预知的。但是在大型程序中，如果每次调用都需要去逐一检查错误，会使代码变得复杂，到处充斥着if...else，并且严重降低代码的可读性，而且人的因素也是不可依赖的，程序员可能并不会把这些问题当一回事，从而导致业务异常。在这种背景下，逐渐形成了异常处理机制。
PHP中的异常，是程序运行中不符合预期的情况及与正常流程不同的状况。一种不正常的情况，就是按照正常逻辑不该出错但仍然出错的情况，这属于逻辑和业务流程的一种中断，而不是语法错误。PHP中的错误则属于自身问题，是一种非法语法或者是环境问题导致的、编译器无法通过检查甚至是无法运行的情况。
在各种语言中，异常（exception）和错误（error）的概念是不一样的。PHP中，遇到任何自身错误都会触发错误，而不是抛出异常。PHP一旦遇到非正常的代码，通常都是触发错误，而不是抛出异常。在这个意义上，如果想使用异常处理机制来处理不可预料的问题，是做不到的。比如，想在文件不存在的情况下或者是数据库连接打不开的情况下触发异常是不可行的，在PHP中会把它作为错误抛出，而不会作为异常自动捕获。
比如下面的经典的除零问题：[php] view plain copy

1. <?php  
2.   
3. $a = null;  
4. try {  
5.     $a = 5 / 0;  
6.     echo $a , PHP_EOL;  
7. } catch (exception $e) {  
8.     $e->getMessage();  
9.     $a = -1;  
10. }  
11.   
12. echo $a;  

运行：
[php] view plain copy

1. Warning: Division by zero in C:\laragon\www\php_book\1_16_exception.php on line 13  
2.   
3. Call Stack:  
4.     0.0010     349728   1. {main}() C:\laragon\www\php_book\1_16_exception.php:0  

可以看到，对于除零这种“异常”情况，PHP认为这是一个错误，直接触发错误，而不会自动抛出异常使程序进入异常流程，即没有进入异常分支，也没有处理异常。PHP只有在你主动throw后，才会捕获异常。也就是说，PHP通常是无法自动 捕获有意义的异常的，它把所有不正常的情况都视为错误，而如果想要捕获这个异常呢，就需要使用if...else结构，保证代码是正常的，然后判断如果除数为0的话，则手动抛出异常，再去捕获。
PHP中的异常机制是不足的，绝大多数情况下无法自动抛出异常，必须用if...else先进行判断，再手动抛出异常。而手动抛异常的意义其实并不大，因为这意味着在代码中已经充分预期到错误的出现，也就算不上真正的‘异常’，同时，这种方式还会使业务的逻辑判断和处理变成纷繁复杂。
注意：Java有一套完整的异常机制，内置很多异常类会自动捕获各种各样的异常，不需要程序员去判断各种异常情况后再手动抛出，编译器会代替程序员进行判断业务是否发生错误，如果发生了则自动抛出异常。所以对于上面的除零问题，Java也可以捕获到而不像PHP那样会抛出错误。

1.2 PHP的异常处理用法

下面使用PHP的异常处理来对表单进行分门别类的处理：[php] view plain copy

1. <?php  
2.   
3. class emailException extends exception  
4. {  
5.   
6. }  
7.   
8. class pwdException extends exception  
9. {  
10.     public function __toString()  
11.     {  
12.         // 改写抛出异常结果  
13.         return "异常 {$this->getCode()} : {$this->getMessage()} in File : {$this->getFile()} on line : {$this->getLine()}" . PHP_EOL;  
14.     }  
15. }  
16.   
17. function reg($reg_info = null)  
18. {  
19.     if (empty($reg_info) || !isset($reg_info)) {  
20.         throw new Exception('参数非法');  
21.     }  
22.   
23.     if (empty($reg_info['email'])) {  
24.         throw new emailException('邮件为空');  
25.     }  
26.   
27.     if ($reg_info['pwd'] != $reg_info['repwd']) {  
28.         throw new pwdException('两次密码不一致');  
29.     }  
30.   
31.     echo '注册成功';  
32. }  
33.   
34. try {  
35.     reg(['email' => '8448@qq.com', 'pwd' => 123456, 'repwd' => 12345678]);  
36. } catch (emailException $ee) {  
37.     echo $ee->getMessage();  
38. } catch (pwdException $ep) {  
39.     echo PHP_EOL , $ep;  
40.     echo '特殊处理';  
41. } catch (Exception $e) {  
42.     echo $e->getTraceAsString();  
43.     echo PHP_EOL , '其他情况,统一处理';  
44. }  

运行：[php] view plain copy

1. 异常 0 : 两次密码不一致 in File : C:\laragon\www\php_book\1_18_exception.php on line : 35  
2. 特殊处理  

在这里，对表单进行异常处理，通过重写异常类、手动抛出异常的方式进行异常处理，这是一种业务异常。
PHP中使用异常处理机制的场景：

• 对程序的悲观预测：比如说这段代码在高并发下可能会产生死锁，那么可以悲观的抛出异常，然后在死锁的时候进行捕获，对异常进行细致的处理
• 程序的需要和对业务的关注：异常是业务处理中必不可少的环节，不能对异常视而不见
• 语言级别的健壮性要求：一旦异常发生后，需要使用try...catch把异常造成的逻辑中断破坏降低到最小范围内，并且经过补救处理后不影响业务逻辑的完整性，乱抛异常和只抛异常而不捕获，或者捕获而不补救，会导致数据混乱

1.3 捕获异常的两种方式

比如有个上传文件的业务需求，要把上传的文件保存到一个目录里，并且在数据库中插入这个文件的记录，那么这两步就是互相关联、密不可分的一个集成的业务，缺一不可。使用异常的代码如下：[php] view plain copy

1. <?php  
2.   
3. try {  
4.     // 可能出错的代码段  
5.     if (文件上传不成功) {  
6.         throw(上传异常);  
7.     }   
8.   
9.     if (插入数据库不成功) {  
10.         throw(数据库操作异常);  
11.     }  
12. } catch (异常) {  
13.     // 必须的补救措施，如删除文件、删除数据库插入记录    
14. }  
15.   
16. // ....  

也可以使用这样的方式：[php] view plain copy

1. <?php  
2.   
3. 上传   
4. {  
5.     if (文件上传不成功) {  
6.         throw(上传异常);  
7.     }   
8.   
9.     if (插入数据库不成功) {  
10.         throw(数据库操作异常);  
11.     }     
12.   
13.     // ....  
14. }  
15.   
16. try {  
17.     上传;  
18.     // ....  
19. } catch (上传异常) {  
20.     // 必须的补救措施，如删除文件、删除数据库插入记录    
21. } catch (其他异常) {  
22.     // 记录日志等  
23. }  

上面两种捕获异常的方式，前一种是在异常发生时立刻捕获，后一种是分散抛异常集中捕获。
如果业务很重要，那么异常就需要越早处理约好，以保证程序在意外情况下保持业务处理的一致性。比如说一个操作有多个前提步骤，突然最后一个步骤异常了，那么其他的前提操作都要消除掉才行，以保证数据的一致性，并且在这种核心业务下，有大量的代码来做善后工作，进行数据补救，所以对于这种情况下需要使用第一种捕获异常的方式。
如果异常不是那么重要，并且在单一入口、MVC风格的应用中，为了保持代码流程的统一，则往往使用后一种异常捕获的方式。

1.4 PHP的错误级别

PHP手册中一共定义了16个级别的错误，不过一般用不到这么多，大致可以分为以下几类：

• deprecated：最低级别的错误，表示不推荐、不建议，比如说PHP 5中使用ereg函数会报此类错误（注：PHP 7 已经移除该函数，所以PHP7使用ereg会报致命错误），这种错误一般由于使用不推荐、过时的函数或者是语法造成的，虽不影响正常流程，但还是建议修正
  
• notice：通知级别的错误，一般是语法存在不当的地方，比如使用未定义的变量，比如数组索引是字符的时候没有加引号等，这种错误不影响正常流程，但是建议修正
  
• warning：警告级别的错误，在语法中出现很不恰当的情况下会报此错误，比如函数参数不匹配的时候，这种级别的错误会导致得不到预期的结果，需要修改代码
  
• fetal error：致命错误，会直接导致PHP流程的提前终结，后面的代码不会执行了，这种情况必须修改该错误
  
• prase error：语法解析错误，最高级别的错误，比如说少了一个分号等，后面的代码也不会执行的。
  

deprecated错误（只有在PHP7以下版本才会报）：[php] view plain copy

1. <?php  
2. $date = '2012-12-20';  
3.   
4. // 如果是在PHP7.0以下的版本的话会报deprecated错误，不建议使用ereg而是用preg_match来代替  
5. // 如果是在PHP7.0以上版本的话，由于PHP7.0版本移除掉ereg方法了，所以这里会报致命错误，下面的代码也不会执行了  
6. if (ereg("([0-9]{4}) - ([0-9]{1, 2}) - ([0-9]{1, 2})", $date, $regs)) {  
7.     echo "$regs[3] . $regs[2] . $regs[1]";  
8. } else {  
9.     echo "Invalid date format: $date";  
10. }  

运行：[php] view plain copy

1. PHP Deprecated:  Function ereg() is deprecated in C:\laragon\www\php_book\1_20_error.php on line 14  
2.   
3. Deprecated: Function ereg() is deprecated in C:\laragon\www\php_book\1_20_error.php on line 14  
4. PHP Warning:  ereg(): REG_BADBR in C:\laragon\www\php_book\1_20_error.php on line 14  

notice错误：[php] view plain copy

1. <?php  
2.   
3. if ($i > 5) {  
4.     echo '$i 没有初始化' , PHP_EOL;  
5. }  

运行：[php] view plain copy

1. Notice: Undefined variable: i in C:\laragon\www\php_book\1_20_error.php on line 10  
2.   
3. Call Stack:  
4.     0.0000     352544   1. {main}() C:\laragon\www\php_book\1_20_error.php:0  

以及：
[php] view plain copy

1. <?php  
2.   
3. $a = ['o' => 2, 4, 6, 8];  
4. echo $a[o];  

运行：[php] view plain copy

1. Notice: Use of undefined constant o - assumed 'o' in C:\laragon\www\php_book\test.php on line 12  
2.   
3. Call Stack:  
4.     0.0000     349800   1. {main}() C:\laragon\www\php_book\test.php:0  
5.   
6. 2  

warning错误：[php] view plain copy

1. <?php  
2. $a = ['o' => 2, 4, 6, 8];  
3. // 由于array_sum只能接收一个参数，所以这里会报Warning  
4. $result = array_sum($a, 3);  

运行：[php] view plain copy

1. Warning: array_sum() expects exactly 1 parameter, 2 given in C:\laragon\www\php_book\test.php on line 10  
2.   
3. Call Stack:  
4.     0.0000     349416   1. {main}() C:\laragon\www\php_book\test.php:0  
5.     0.0000     349416   2. array_sum() C:\laragon\www\php_book\test.php:10  

fetal error错误：[php] view plain copy

1. <?php  
2.   
3. echo fun();  
4.   
5. // 致命错误后下面的代码不会被执行  
6. echo '2222222';  

运行：[php] view plain copy

1. Fatal error: Uncaught Error: Call to undefined function fun() in C:\laragon\www\php_book\test.php on line 9  
2.   
3. Error: Call to undefined function fun() in C:\laragon\www\php_book\test.php on line 9  
4.   
5. Call Stack:  
6.     0.0000     349016   1. {main}() C:\laragon\www\php_book\test.php:0  

prase error错误：[php] view plain copy

1. <?php  
2.   
3.   
4. echo '2222222';  

运行：[php] view plain copy

1. Parse error: syntax error, unexpected end of file, expecting ',' or ';' in C:\laragon\www\php_book\test.php on line 4  

PHP中的错误可以使用error_reporting(0)来屏蔽所有的错误，也可以通过在函数前面加@符号来抑制错误信息的输出，比如@mysql_connect()等。

1.5 PHP中的错误处理机制

PHP里有一套错误处理机制，可以使用set_error_handler接管PHP错误处理，也可以使用trigger_error函数主动抛出错误。set_error_handler() 函数设置用户自定义的错误处理函数，函数用于创建运行期间的用户自己的错误处理方法，它需要先创建一个错误处理函数，然后设置错误级别，语法如下：[php] view plain copy

1. set_error_handler(error_function, error_types)  

参数描述如下：
error_function：规定发生错误时运行的函数，必需error_types：规定在哪个错误报告级别会显示用户定义的错误，可选，默认为E_ALL
注意：如果使用该函数，会完全绕过标准PHP错误处理函数，如果有必要，用户定义的错误处理程序必须终止(die)脚本。另外，如果使用该函数，代码里的错误抑制符@会失效，这种错误也会被显示出来。
自定义的错误处理函数必须要有4个输入变量：$errno、$errstr、$errfile、$errline
下面是例子：[php] view plain copy

1. <?php  
2. /** 
3.  * 自定义的异常处理函数 
4.  * 注意：并不能接管致命错误Fatal error 
5.  */  
6.   
7. function customError($errno, $errstr, $errfile, $errline)  
8. {  
9.     echo " 错误代码: [${errno}] ${errstr}" . PHP_EOL;  
10.     echo " 错误所在的代码行: {$errline} 文件 {$errfile}" . PHP_EOL;  
11.     echo " PHP版本:" . PHP_VERSION . "(" . PHP_OS . ")" . PHP_EOL;  
12.   
13.     // 如果觉得有报错的话，需要停止执行的话，可以使用die来终止程序，不加die的话则会继续输出  
14. //    die();  
15. }  
16.   
17. // 使用自定义的异常处理函数来替代PHP的错误处理  
18. set_error_handler('customError', E_ALL|E_STRICT);  
19.   
20. $a = ['o' => 2, 4, 6, 8];  
21. // 由于这里没有加引号，所以这里会报Notice  
22. echo $a[o];  
23. echo PHP_EOL;  
24.   
25. // 由于array_sum只能接收一个参数，所以这里会报Warning  
26. $result = array_sum($a, 3);  
27. echo PHP_EOL;  
28.   
29. // 由于$i没有定义，所以这里会报Notice  
30. if ($i > 5) {  
31.     echo '$i 没有初始化' , PHP_EOL;  
32. }  
33.   
34. // 这里会报致命错误Fatal error  
35. echo fun();  

运行：[php] view plain copy

1.  错误代码: [8] Use of undefined constant o - assumed 'o'  
2.  错误所在的代码行: 34 文件 C:\laragon\www\php_book\1_21_setError.php  
3.  PHP版本:7.1.1(WINNT)  
4. 2  
5.  错误代码: [2] array_sum() expects exactly 1 parameter, 2 given  
6.  错误所在的代码行: 38 文件 C:\laragon\www\php_book\1_21_setError.php  
7.  PHP版本:7.1.1(WINNT)  
8.   
9.  错误代码: [8] Undefined variable: i  
10.  错误所在的代码行: 42 文件 C:\laragon\www\php_book\1_21_setError.php  
11.  PHP版本:7.1.1(WINNT)  
12.   
13. Fatal error: Uncaught Error: Call to undefined function fun() in C:\laragon\www\php_book\1_21_setError.php on line 47  
14.   
15. Error: Call to undefined function fun() in C:\laragon\www\php_book\1_21_setError.php on line 47  
16.   
17. Call Stack:  
18.     0.0110     353256   1. {main}() C:\laragon\www\php_book\1_21_setError.php:0  

可以看到，对于notice错误、warning错误都可以接管，但是对于fetal error并不能接管，依然还是会输出该错误。
在PHP异常中，异常处理机制是有限的，无法自动抛出异常，必须手动进行，并且内置异常也是有限，PHP把许多异常看做错误，比如除零问题，被看做是warning错误，这样的话，我们可以使用set_error_handler接管，进而主动抛出异常，把上面的代码优化一下加入异常处理机制即可，代码如下：[php] view plain copy

1. <?php  
2. /** 
3.  * 使用自定义的异常处理函数处理非致命错误和异常 
4.  * 注意：并不能接管致命错误Fatal error 
5.  */  
6.   
7. function customError($errno, $errstr, $errfile, $errline)  
8. {  
9.     $res = " 错误代码: [${errno}] ${errstr}" . PHP_EOL;  
10.     $res .= " 错误所在的代码行: {$errline} 文件 {$errfile}" . PHP_EOL;  
11.     $res .= " PHP版本:" . PHP_VERSION . "(" . PHP_OS . ")" . PHP_EOL;  
12.     // 自定义错误处理时，手动抛出异常  
13.     throw new Exception($res);  
14. }  
15.   
16. // 使用自定义的异常处理函数来替代PHP的错误处理  
17. set_error_handler('customError', E_ALL|E_STRICT);  
18.   
19. try {  
20.     $a = 5 / 0;  
21. //    $a = new a();  
22. } catch (Exception $e) {  
23.     echo $e->getMessage();  
24. }  

运行：[php] view plain copy

1. 错误代码: [2] Division by zero  
2.  错误所在的代码行: 32 文件 C:\laragon\www\php_book\1_22_setError.php  
3.  PHP版本:7.1.1(WINNT)  

这样就可以捕获到异常和非致命的错误，弥补PHP异常处理机制的部分不足，这种曲折迂回的处理方式存在的问题是：必须靠程序员来掌控对异常的处理，对于异常高发区、敏感区，如果程序员处理不好，就会导致业务数据不一致的问题，而优点在于可以获得程序运行时的上下文信息，以进行针对性的补救。

完整的加上错误抑制符的捕获异常和非致命错误的代码为：[php] view plain copy

1. <?php  
2. /** 
3.  * 使用自定义的异常处理函数会导致错误抑制符@失效 
4.  * 注意：并不能接管致命错误Fatal error 
5.  */  
6.   
7. /** 
8.  * 自定义的异常处理函数 
9.  */  
10. function customError($errno, $errstr, $errfile, $errline)  
11. {  
12.     $res = " 错误代码: [${errno}] ${errstr}" . PHP_EOL;  
13.     $res .= " 错误所在的代码行: {$errline} 文件 {$errfile}" . PHP_EOL;  
14.     $res .= " PHP版本:" . PHP_VERSION . "(" . PHP_OS . ")" . PHP_EOL;  
15.     // 自定义错误处理时，手动抛出异常  
16.     throw new Exception($res);  
17. }  
18.   
19. // 使用自定义的异常处理函数来替代PHP的错误处理  
20. set_error_handler('customError', E_ALL|E_STRICT);  
21.   
22. try {  
23.     $a = ['o' => 2, 4, 6, 8];  
24.     // 由于这里没有加引号，所以这里会报Notice  
25.     echo @$a[o];  
26.     echo PHP_EOL;  
27.   
28.     // 由于array_sum只能接收一个参数，所以这里会报Warning  
29.     $result = @array_sum($a, 3);  
30.     echo PHP_EOL;  
31.   
32.     // 由于$i没有定义，所以这里会报Notice  
33.     if (@$i > 5) {  
34.         echo '$i 没有初始化' , PHP_EOL;  
35.     }  
36.     echo PHP_EOL;  
37.   
38.     // Warning错误  
39.     $a = @(5 / 0);  
40.     echo PHP_EOL;  
41.   
42.     // 这里报致命错误Fatal error  
43.     $a = new a();  
44.     echo PHP_EOL;  
45.   
46.     // 这里会报致命错误Fatal error  
47.     echo fun();  
48. } catch (Exception $e) {  
49.     echo $e->getMessage();  
50. }  

运行：[php] view plain copy

1. 错误代码: [8] Use of undefined constant o - assumed 'o'  
2. 错误所在的代码行: 34 文件 C:\laragon\www\php_book\1_22_setError_2.php  
3. PHP版本:7.1.1(WINNT)  

一旦抛出异常，下面的代码不会运行，并且错误抑制符@会失效

1.6 捕获致命错误

使用上面的方法虽然捕获不到致命错误，但是对于致命错误呢，还是可以通过一些特殊方法对这种错误进行处理的，需要用到一个函数，register_shutdown_function。这个函数的具体用法可以参考：【函数】register_shutdown_function函数详解【原创】
代码如下：[php] view plain copy

1. <?php  
2. /** 
3.  * register_shutdown_function,注册一个会在php中止时执行的函数,中止的情况包括发生致命错误、die之后、exit之后、执行完成之后都会调用register_shutdown_function里面的函数 
4.  */  
5.   
6. class Shutdown  
7. {  
8.     public function stop()  
9.     {  
10.         echo 'Begin.' . PHP_EOL;  
11.         // 如果有发生错误（所有的错误，包括致命和非致命）的话，获取最后发生的错误  
12.         if (error_get_last()) {  
13.             print_r(error_get_last());  
14.         }  
15.   
16.         // ToDo:发生致命错误后恢复流程处理  
17.   
18.         // 中止后面的所有处理  
19.         die('Stop.');  
20.     }  
21. }  
22.   
23. // 当PHP终止的时候（执行完成或者是遇到致命错误中止的时候）会调用new Shutdown的stop方法  
24. register_shutdown_function([new Shutdown(), 'stop']);  
25.   
26. // 将因为致命错误而中止  
27. $a = new a();  
28.   
29. // 这一句并没有执行，也没有输出  
30. echo '必须终止';  

运行：[php] view plain copy

1. Fatal error: Uncaught Error: Class 'a' not found in C:\laragon\www\php_book\1_23_register_shutdown.php on line 32  
2.   
3. Error: Class 'a' not found in C:\laragon\www\php_book\1_23_register_shutdown.php on line 32  
4.   
5. Call Stack:  
6.     0.0000     351920   1. {main}() C:\laragon\www\php_book\1_23_register_shutdown.php:0  
7.   
8. Begin.  
9. Array  
10. (  
11.     [type] => 1  
12.     [message] => Uncaught Error: Class 'a' not found in C:\laragon\www\php_book\1_23_register_shutdown.php:32  
13. Stack trace:  
14. #0 {main}  
15.   thrown  
16.     [file] => C:\laragon\www\php_book\1_23_register_shutdown.php  
17.     [line] => 32  
18. )  
19. Stop.  

但是很遗憾的是，错误的代码还是会显示出来，另外，如果把这个致命错误的处理和非致命错误的错误封装在一起，即不论是非致命错误还是致命错误都是会报错，而且报错的格式也是一样的。

更新：PHP7 新增了Throwable和Error异常类，Throwable类是可以捕获到致命错误Error以及异常Exception类，所以可以使用Throwable或者是Error来替代register_shutdown_function函数。（Error类只能捕获错误，不能捕获异常）

代码如下：[php] view plain copy

1. <?php  
2.   
3. try {  
4.   
5.     // 将因为致命错误而中止  
6.   
7.     $a = new a();  
8.   
9.     // 这一句并没有执行，也没有输出  
10.   
11.     echo 'end';  
12.   
13. } catch (Throwable $e) {  
14.   
15.     print_r($e);  
16.   
17.     echo $e->getMessage();  
18.   
19. }  

运行：[php] view plain copy

1. Error Object  
2. (  
3.     [message:protected] => Class 'a' not found  
4.     [string:Error:private] =>  
5.     [code:protected] => 0  
6.     [file:protected] => C:\laragon\www\php_book\throwable.php  
7.     [line:protected] => 5  
8.     [trace:Error:private] => Array  
9.         (  
10.         )  
11.   
12.     [previous:Error:private] =>  
13.     [xdebug_message] =>  
14. Error: Class 'a' not found in C:\laragon\www\php_book\throwable.php on line 5  
15.   
16. Call Stack:  
17.     0.0000     349856   1. {main}() C:\laragon\www\php_book\throwable.php:0  
18.   
19. )  
20. Class 'a' not found  

这样的话，PHP7中使用Throwable来捕获的话比使用register_shutdown_function这个函数来得更方便，也更推荐Throwable。
Todo：屏蔽致命错误 Todo：封装非致命错误和致命错误的处理，使得输出的格式是一模一样的
针对上面的两个需求，自己写了两个方案来解决这个。第一个方案：[php] view plain copy

1. <?php  
2. /** 
3.  * 使用自定义的异常处理函数,捕获所有的错误处理,包括非致命的和致命的 
4.  * 注意：Throwable是PHP7的新特性，即该程序只能在PHP7及以上版本运行 
5.  * 注意：虽然能获取到所有的错误和异常，但是并不能实现统一处理 
6.  */  
7.   
8. // 使用自定义的异常处理函数来替代PHP的错误处理  
9. set_error_handler('UnFetalError');  
10.   
11. /** 
12.  * 自定义错误处理方法，处理非致命错误 
13.  * @param $errno int 错误代码 
14.  * @param $errstr string 错误信息 
15.  * @param $errfile string 错误文件 
16.  * @param $errline int  错误行号 
17.  * @throws Exception 
18.  */  
19. function UnFetalError($errno, $errstr, $errfile, $errline)  
20. {  
21.     $res = ShowError($errno, $errstr, $errfile, $errline);  
22.     throw new Exception($res, $errno);  
23. }  
24.   
25. /** 
26.  * 致命错误处理方法，处理致命错误 
27.  * @param Throwable $e 
28.  * @return string 
29.  */  
30. function FetalError(Throwable $e)  
31. {  
32.     $res = ShowError($e->getCode(), $e->getMessage(), $e->getFile(), $e->getLine());  
33.     return $res;  
34. }  
35.   
36. /** 
37.  * 输出错误信息的格式 
38.  * @param $errno int 错误代码 
39.  * @param $errstr string 错误信息 
40.  * @param $errfile string 错误文件 
41.  * @param $errline int  错误行号 
42.  * @return string 
43.  */  
44. function ShowError($errno, $errstr, $errfile, $errline)  
45. {  
46.     $res = " 错误代码: [{$errno}]" . PHP_EOL;  
47.     $res .= " 错误信息: {$errstr}" . PHP_EOL;  
48.     $res .= " 错误所在的代码行: {$errline} 行" . PHP_EOL;  
49.     $res .= " 文件: {$errfile}" . PHP_EOL;  
50.     $res .= " PHP版本:" . PHP_VERSION . " (" . PHP_OS . ")" . PHP_EOL;  
51.     return $res;  
52. }  
53.   
54. function test()  
55. {  
56.     // Warning  
57. //    $a = 5 / 0;  
58. //    echo PHP_EOL;  
59.   
60.     // Fatal error  
61.     echo fun();  
62.     echo PHP_EOL;  
63.     echo 'end';  
64. }  
65.   
66. try {  
67.     test();  
68.   
69.     // 其他的业务代码（可能会抛异常）  
70.     // ...  
71. } catch (Throwable $e) {  
72.     // 对错误进行筛选，筛选出致命错误和非致命错误  
73.     switch ($e->getCode()) {  
74.         case 0:  
75.             echo '处理致命错误：' . PHP_EOL;  
76.             echo FetalError($e);  
77.             break;  
78.         default:  
79.             echo '处理非致命错误：' . PHP_EOL;  
80.             echo $e->getMessage();  
81.             break;  
82.     }  
83. } catch (Exception $e) {  
84.     // 如果PHP版本是低于7的话，那么最好是再加上这个catch来捕获异常（不过不能捕获致命错误）  
85.     echo $e->getMessage();  
86. }  

运行：

[php] view plain copy

1. 处理致命错误：  
2.  错误代码: [0]  
3.  错误信息: Call to undefined function fun()  
4.  错误所在的代码行: 57 行  
5.  文件: C:\laragon\www\php_book\1_26_allError.php  
6.  PHP版本:7.1.1 (WINNT)  

上面的方案虽然能实现需求，但是会把致命错误和非致命错误分开处理。
下面的方案是统一处理致命错误、非致命错误：[php] view plain copy

1. <?php  
2. /** 
3.  * 采用多重try...catch来捕获所有的异常和错误，并且进行统一处理 
4.  * 使用自定义的异常处理函数,捕获所有的错误处理,包括非致命的和致命的 
5.  * 注意：Throwable是PHP7的新特性，即该程序只能在PHP7及以上版本运行 
6.  */  
7.   
8. // 使用自定义的异常处理函数来替代PHP的错误处理  
9. set_error_handler('CustomError');  
10.   
11. /** 
12.  * 自定义错误处理方法，处理错误 
13.  * @param $errno int 错误代码 
14.  * @param $errstr string 错误信息 
15.  * @param $errfile string 错误文件 
16.  * @param $errline int  错误行号 
17.  * @throws Exception 
18.  */  
19. function CustomError($errno, $errstr, $errfile, $errline)  
20. {  
21.     $res = ShowError($errno, $errstr, $errfile, $errline);  
22.     throw new Exception($res, $errno);  
23. }  
24.   
25. /** 
26.  * 输出错误信息的格式 
27.  * @param $errno int 错误代码 
28.  * @param $errstr string 错误信息 
29.  * @param $errfile string 错误文件 
30.  * @param $errline int  错误行号 
31.  * @return string 
32.  */  
33. function ShowError($errno, $errstr, $errfile, $errline)  
34. {  
35.     $res = " 错误代码: [{$errno}]" . PHP_EOL;  
36.     $res .= " 错误信息: {$errstr}" . PHP_EOL;  
37.     $res .= " 错误所在的代码行: {$errline} 行" . PHP_EOL;  
38.     $res .= " 文件: {$errfile}" . PHP_EOL;  
39.     $res .= " PHP版本:" . PHP_VERSION . " (" . PHP_OS . ")" . PHP_EOL;  
40.     return $res;  
41. }  
42.   
43. function test()  
44. {  
45.     // Warning  
46. //    $a = 5 / 0;  
47. //    echo PHP_EOL;  
48.   
49.     // Fatal error  
50.     echo fun();  
51.     echo PHP_EOL;  
52.   
53.     // Fatal error  
54.     $a = new a();  
55.     echo PHP_EOL;  
56.   
57.     echo 'end';  
58. }  
59.   
60. try {  
61.     try {  
62.         test();  
63.   
64.         // 其他的业务代码（可能会抛异常）  
65.     } catch (Error $e) {    // 处理致命错误，转化为异常抛出给上一层  
66.         CustomError($e->getCode(), $e->getMessage(), $e->getFile(), $e->getLine());  
67.     }  
68. } catch (Throwable $e) {  
69.     echo $e->getMessage();  
70. }  

采用多个try...catch来捕获，把致命错误转化为异常抛出给上一层，所有的错误都在最上一层的catch(Throwable $e)中进行处理。
上面的两个方案的缺点是只能运行在PHP7版本及以上了，PHP7版本以下并没有Error类和Throwable类。所以PHP7版本以下的话需要通过register_shutdown_function来实现捕获致命错误。