restore_error_handler() 是PHP内置的错误处理函数，用于恢复之前的错误处理函数。当使用set_error_handler()设置自定义错误处理器后，可以使用此函数恢复到之前设置的处理函数（通常是PHP内置的错误处理器）。
set_error_handler()配对使用，用于临时替换错误处理器或在特定代码块完成后恢复原始设置。
restore_error_handler()会恢复到调用栈中上一层的错误处理器。如果没有前一个错误处理器，会恢复到PHP内置的错误处理器。
void restore_error_handler(void)这个函数没有参数，也没有返回值（void）。调用后，错误处理器会恢复到之前的状态。
void - 这个函数不返回任何值。
PHP维护了一个错误处理器的调用栈。每次调用set_error_handler()都会将新的处理器压入栈顶。调用restore_error_handler()则会弹出栈顶的处理器，恢复使用前一个处理器。
使用示例：
<?php
// 初始状态：使用PHP内置错误处理器
// 设置第一个自定义处理器
set_error_handler('handler1');
// 当前：使用handler1
// 设置第二个自定义处理器
set_error_handler('handler2');
// 当前：使用handler2
// 恢复到上一个处理器
restore_error_handler();
// 当前：恢复使用handler1
// 再次恢复
restore_error_handler();
// 当前：恢复使用PHP内置处理器
演示如何使用restore_error_handler()恢复错误处理器：
<?php
// 自定义错误处理器1
function customErrorHandler1($errno, $errstr, $errfile, $errline) {
echo "<div style='background:#e7f3ff; padding:10px; margin:5px; border:1px solid #b3d7ff;'>";
echo "<strong>[处理器1]</strong> 错误: " . htmlspecialchars($errstr) . " 在 " . $errfile . " 第 " . $errline . " 行";
echo "</div>";
return true; // 阻止PHP内置处理器执行
}
// 自定义错误处理器2
function customErrorHandler2($errno, $errstr, $errfile, $errline) {
echo "<div style='background:#fff3cd; padding:10px; margin:5px; border:1px solid #ffeaa7;'>";
echo "<strong>[处理器2]</strong> 错误: " . htmlspecialchars($errstr) . " 在 " . $errfile . " 第 " . $errline . " 行";
echo "</div>";
return true; // 阻止PHP内置处理器执行
}
echo "<h4>1. 使用PHP内置错误处理器（默认）:</h4>";
echo $undefinedVar1; // 这会产生一个Notice
echo "<h4>2. 设置并使用自定义错误处理器1:</h4>";
set_error_handler("customErrorHandler1");
echo $undefinedVar2; // 这会产生一个Notice，被customErrorHandler1处理
echo "<h4>3. 设置并使用自定义错误处理器2:</h4>";
set_error_handler("customErrorHandler2");
echo $undefinedVar3; // 这会产生一个Notice，被customErrorHandler2处理
echo "<h4>4. 恢复到上一个错误处理器（处理器1）:</h4>";
restore_error_handler();
echo $undefinedVar4; // 这会产生一个Notice，被customErrorHandler1处理
echo "<h4>5. 恢复到PHP内置错误处理器:</h4>";
restore_error_handler();
echo $undefinedVar5; // 这会产生一个Notice，被PHP内置处理器处理
echo "<h4>6. 尝试再次恢复（已恢复到内置处理器）:</h4>";
restore_error_handler(); // 没有效果，因为已经是最底层
echo $undefinedVar6; // 这会产生一个Notice，仍被PHP内置处理器处理演示如何临时设置错误处理器，在处理完特定代码后恢复：
<?php
// 原始的错误处理器
function originalErrorHandler($errno, $errstr, $errfile, $errline) {
echo "<div style='background:#f8f9fa; padding:10px; margin:5px; border:1px solid #ddd;'>";
echo "<strong>[原始处理器]</strong> 错误: " . htmlspecialchars($errstr);
echo "</div>";
return true;
}
// 临时错误处理器
function temporaryErrorHandler($errno, $errstr, $errfile, $errline) {
echo "<div style='background:#d4edda; padding:10px; margin:5px; border:1px solid #c3e6cb;'>";
echo "<strong>[临时处理器]</strong> 错误: " . htmlspecialchars($errstr);
echo "</div>";
return true;
}
// 设置原始错误处理器
set_error_handler("originalErrorHandler");
echo "<h4>1. 使用原始错误处理器:</h4>";
echo $var1; // 被originalErrorHandler处理
echo "<h4>2. 临时替换错误处理器处理特定代码块:</h4>";
// 保存当前错误处理器
$oldHandler = set_error_handler("temporaryErrorHandler");
echo "临时处理器激活:<br>";
echo $var2; // 被temporaryErrorHandler处理
echo $var3; // 被temporaryErrorHandler处理
echo "<h4>3. 恢复原始错误处理器:</h4>";
// 恢复到之前的处理器
restore_error_handler();
echo "已恢复原始处理器:<br>";
echo $var4; // 被originalErrorHandler处理
echo "<h4>4. 另一种方式：使用try-finally确保恢复:</h4>";
// 设置原始处理器
set_error_handler("originalErrorHandler");
try {
// 临时设置新的处理器
set_error_handler("temporaryErrorHandler");
echo "在try块中使用临时处理器:<br>";
echo $var5; // 被temporaryErrorHandler处理
// 这里可能抛出异常
if (rand(0, 1)) {
throw new Exception("随机异常");
}
} catch (Exception $e) {
echo "捕获异常: " . $e->getMessage() . "<br>";
} finally {
// 无论是否发生异常，都恢复原始处理器
restore_error_handler();
echo "<div style='background:#d1ecf1; padding:10px; margin:10px 0; border:1px solid #bee5eb;'>";
echo "finally块：已确保恢复原始错误处理器";
echo "</div>";
}
echo "<h4>5. 验证处理器已恢复:</h4>";
echo $var6; // 被originalErrorHandler处理演示多层嵌套的错误处理器设置和恢复：
<?php
// 多个错误处理器
function handlerA($errno, $errstr, $errfile, $errline) {
echo "<div style='background:#e7f3ff; padding:5px; margin:2px; border-left:4px solid #b3d7ff;'>";
echo "[处理器A] " . htmlspecialchars($errstr);
echo "</div>";
return true;
}
function handlerB($errno, $errstr, $errfile, $errline) {
echo "<div style='background:#fff3cd; padding:5px; margin:2px; border-left:4px solid #ffeaa7;'>";
echo "[处理器B] " . htmlspecialchars($errstr);
echo "</div>";
return true;
}
function handlerC($errno, $errstr, $errfile, $errline) {
echo "<div style='background:#d4edda; padding:5px; margin:2px; border-left:4px solid #c3e6cb;'>";
echo "[处理器C] " . htmlspecialchars($errstr);
echo "</div>";
return true;
}
echo "<h4>嵌套设置错误处理器:</h4>";
// 开始：PHP内置处理器
echo "初始状态: PHP内置处理器<br>";
echo $var1; // PHP内置处理器处理
// 第一层
set_error_handler("handlerA");
echo "<div style='margin-left:20px;'>";
echo "第一层: handlerA<br>";
echo $var2; // handlerA处理
// 第二层
set_error_handler("handlerB");
echo "<div style='margin-left:40px;'>";
echo "第二层: handlerB<br>";
echo $var3; // handlerB处理
// 第三层
set_error_handler("handlerC");
echo "<div style='margin-left:60px;'>";
echo "第三层: handlerC<br>";
echo $var4; // handlerC处理
echo "</div>";
// 开始恢复
echo "</div>";
restore_error_handler();
echo "恢复一层: 回到handlerB<br>";
echo $var5; // handlerB处理
echo "</div>";
restore_error_handler();
echo "恢复两层: 回到handlerA<br>";
echo $var6; // handlerA处理
restore_error_handler();
echo "恢复三层: 回到PHP内置处理器<br>";
echo $var7; // PHP内置处理器处理
echo "<h4>验证调用栈:</h4>";
// 获取当前处理器数量（通过模拟）
function getHandlerStackDepth() {
$depth = 0;
$originalHandler = set_error_handler(function() use (&$depth) {
$depth++;
});
// 不断设置新处理器直到返回null（表示已到PHP内置处理器）
while (set_error_handler(function() {}) !== null) {
$depth++;
}
// 恢复所有处理器
for ($i = 0; $i <= $depth; $i++) {
restore_error_handler();
}
return $depth;
}
echo "当前错误处理器栈深度: " . getHandlerStackDepth() . "（0表示使用PHP内置处理器）";演示在类方法中设置和恢复错误处理器：
<?php
// 错误处理器类
class ErrorHandlerManager {
private $originalHandler = null;
private $handlerStack = [];
/**
* 设置自定义错误处理器
*/
public function setCustomHandler($callback) {
// 保存当前处理器
$this->originalHandler = set_error_handler($callback);
$this->handlerStack[] = $callback;
return $this;
}
/**
* 恢复之前的错误处理器
*/
public function restore() {
if (!empty($this->handlerStack)) {
array_pop($this->handlerStack);
}
restore_error_handler();
return $this;
}
/**
* 恢复到原始处理器（PHP内置）
*/
public function restoreToOriginal() {
$this->handlerStack = [];
// 恢复到最底层
while (restore_error_handler()) {
// 循环直到恢复所有
}
return $this;
}
/**
* 获取当前处理器数量
*/
public function getHandlerCount() {
return count($this->handlerStack);
}
/**
* 临时使用处理器执行代码
*/
public function withHandler($callback, $executionCallback) {
// 保存当前处理器
$previousHandler = set_error_handler($callback);
$this->handlerStack[] = $callback;
try {
$result = $executionCallback();
return $result;
} finally {
// 无论是否异常，都恢复之前的处理器
$this->restore();
}
}
}
// 测试类
echo "<h4>使用ErrorHandlerManager类:</h4>";
$manager = new ErrorHandlerManager();
// 定义几个错误处理器
$handler1 = function($errno, $errstr) {
echo "<div style='color:blue;'>[Handler1] " . htmlspecialchars($errstr) . "</div>";
return true;
};
$handler2 = function($errno, $errstr) {
echo "<div style='color:green;'>[Handler2] " . htmlspecialchars($errstr) . "</div>";
return true;
};
$handler3 = function($errno, $errstr) {
echo "<div style='color:red;'>[Handler3] " . htmlspecialchars($errstr) . "</div>";
return true;
};
// 1. 设置第一个处理器
$manager->setCustomHandler($handler1);
echo "处理器数量: " . $manager->getHandlerCount() . "<br>";
echo $var1; // 被handler1处理
// 2. 设置第二个处理器
$manager->setCustomHandler($handler2);
echo "处理器数量: " . $manager->getHandlerCount() . "<br>";
echo $var2; // 被handler2处理
// 3. 恢复一次
$manager->restore();
echo "恢复后处理器数量: " . $manager->getHandlerCount() . "<br>";
echo $var3; // 被handler1处理
// 4. 使用withHandler临时处理器
echo "<h4>使用withHandler临时处理器:</h4>";
$result = $manager->withHandler($handler3, function() {
echo "在临时处理器中执行代码:<br>";
echo $var4; // 被handler3处理
echo $var5; // 被handler3处理
return "执行完成";
});
echo "结果: " . $result . "<br>";
echo "withHandler后处理器数量: " . $manager->getHandlerCount() . "<br>";
echo $var6; // 被handler1处理（已恢复）
// 5. 恢复到原始处理器
$manager->restoreToOriginal();
echo "<h4>恢复到原始处理器后:</h4>";
echo "处理器数量: " . $manager->getHandlerCount() . "<br>";
echo $var7; // 被PHP内置处理器处理演示在实际应用场景中如何使用restore_error_handler()：
<?php
// 数据库连接类
class DatabaseConnection {
private $connection;
private static $originalErrorHandler = null;
public function __construct($host, $username, $password, $database) {
// 在连接数据库时临时修改错误处理器
$this->setErrorHandlerForConnection();
try {
// 尝试连接数据库
$this->connection = mysqli_connect($host, $username, $password, $database);
if (!$this->connection) {
// 连接失败，抛出异常
throw new Exception("数据库连接失败: " . mysqli_connect_error());
}
echo "<div style='background:#d4edda; padding:10px; margin:10px 0; border:1px solid #c3e6cb;'>";
echo "数据库连接成功";
echo "</div>";
} finally {
// 无论连接是否成功，都恢复原始错误处理器
$this->restoreErrorHandler();
}
}
private function setErrorHandlerForConnection() {
// 保存原始错误处理器
self::$originalErrorHandler = set_error_handler([$this, 'connectionErrorHandler']);
}
private function restoreErrorHandler() {
if (self::$originalErrorHandler !== null) {
restore_error_handler();
}
}
public function connectionErrorHandler($errno, $errstr, $errfile, $errline) {
// 只处理与数据库连接相关的错误
if (strpos($errstr, 'mysqli_connect') !== false) {
// 记录错误但不显示
error_log("数据库连接错误: " . $errstr);
return true; // 阻止错误显示
}
// 其他错误传递给原始处理器
return false;
}
public function query($sql) {
// 执行查询
$result = mysqli_query($this->connection, $sql);
if (!$result) {
throw new Exception("查询失败: " . mysqli_error($this->connection));
}
return $result;
}
}
// 文件处理类
class FileProcessor {
public static function processFile($filename, $processorCallback) {
// 临时错误处理器，静默处理文件错误
$oldHandler = set_error_handler(function($errno, $errstr, $errfile, $errline) {
// 如果是文件不存在的错误，静默处理
if (strpos($errstr, 'failed to open stream') !== false) {
error_log("文件处理错误: " . $errstr);
return true; // 阻止错误显示
}
return false; // 其他错误传递给下一个处理器
});
try {
$result = $processorCallback($filename);
return $result;
} finally {
// 恢复原始错误处理器
restore_error_handler();
}
}
}
// 使用示例
echo "<h4>场景1：数据库连接错误处理</h4>";
try {
// 尝试连接数据库（使用错误的凭据）
$db = new DatabaseConnection('localhost', 'wrong_user', 'wrong_pass', 'nonexistent_db');
} catch (Exception $e) {
echo "<div style='background:#f8d7da; padding:10px; margin:10px 0; border:1px solid #f5c6cb;'>";
echo "捕获异常: " . $e->getMessage();
echo "</div>";
}
// 验证错误处理器已恢复
echo "<h4>验证错误处理器已恢复:</h4>";
echo $undefinedVar; // 应该被PHP默认处理器处理，显示Notice
echo "<h4>场景2：文件处理错误处理</h4>";
$result = FileProcessor::processFile('non_existent_file.txt', function($filename) {
echo "处理文件: " . $filename . "<br>";
$content = file_get_contents($filename);
if ($content === false) {
throw new Exception("无法读取文件");
}
return $content;
});
if ($result === false) {
echo "<div style='background:#fff3cd; padding:10px; margin:10px 0; border:1px solid #ffeaa7;'>";
echo "文件处理失败，但错误被静默处理";
echo "</div>";
}
echo "<h4>再次验证错误处理器已恢复:</h4>";
echo $anotherUndefinedVar; // 应该被PHP默认处理器处理创建一个完整的错误处理器管理工具：
<?php
/**
* 错误处理器管理工具
*/
class ErrorHandlerTool {
private static $handlerStack = [];
private static $originalHandler = null;
/**
* 推入新的错误处理器
*/
public static function push($callback) {
// 如果是第一个处理器，保存原始处理器信息
if (empty(self::$handlerStack)) {
self::$originalHandler = set_error_handler($callback);
} else {
set_error_handler($callback);
}
self::$handlerStack[] = $callback;
return count(self::$handlerStack);
}
/**
* 弹出当前错误处理器
*/
public static function pop() {
if (empty(self::$handlerStack)) {
return false;
}
array_pop(self::$handlerStack);
restore_error_handler();
return true;
}
/**
* 获取当前错误处理器
*/
public static function current() {
if (empty(self::$handlerStack)) {
return null; // 使用PHP内置处理器
}
return end(self::$handlerStack);
}
/**
* 获取处理器栈大小
*/
public static function size() {
return count(self::$handlerStack);
}
/**
* 清除所有自定义处理器，恢复到PHP内置处理器
*/
public static function clear() {
while (!empty(self::$handlerStack)) {
self::pop();
}
return true;
}
/**
* 使用临时处理器执行代码
*/
public static function with($callback, $execution) {
$previousSize = self::size();
try {
self::push($callback);
$result = $execution();
return $result;
} finally {
// 恢复到之前的状态
while (self::size() > $previousSize) {
self::pop();
}
}
}
/**
* 获取处理器栈信息
*/
public static function info() {
$info = [
'stack_size' => count(self::$handlerStack),
'current_handler' => self::current(),
'original_handler' => self::$originalHandler,
'stack' => self::$handlerStack,
];
return $info;
}
}
// 使用示例
echo "<h4>使用ErrorHandlerTool管理错误处理器:</h4>";
// 定义几个处理器
$h1 = function($errno, $errstr) {
echo "[H1] " . htmlspecialchars($errstr) . "<br>";
return true;
};
$h2 = function($errno, $errstr) {
echo "[H2] " . htmlspecialchars($errstr) . "<br>";
return true;
};
$h3 = function($errno, $errstr) {
echo "[H3] " . htmlspecialchars($errstr) . "<br>";
return true;
};
// 1. 初始状态
echo "初始栈大小: " . ErrorHandlerTool::size() . "<br>";
// 2. 添加第一个处理器
ErrorHandlerTool::push($h1);
echo "添加H1后栈大小: " . ErrorHandlerTool::size() . "<br>";
echo $var1; // 被H1处理
// 3. 添加第二个处理器
ErrorHandlerTool::push($h2);
echo "添加H2后栈大小: " . ErrorHandlerTool::size() . "<br>";
echo $var2; // 被H2处理
// 4. 使用临时处理器
echo "<h4>使用with临时处理器:</h4>";
$result = ErrorHandlerTool::with($h3, function() {
echo "在临时处理器中:<br>";
echo $var3; // 被H3处理
echo $var4; // 被H3处理
return "完成";
});
echo "结果: " . $result . "<br>";
echo "with后栈大小: " . ErrorHandlerTool::size() . "<br>";
echo $var5; // 被H2处理（已恢复）
// 5. 弹出处理器
ErrorHandlerTool::pop();
echo "弹出后栈大小: " . ErrorHandlerTool::size() . "<br>";
echo $var6; // 被H1处理
// 6. 清除所有处理器
ErrorHandlerTool::clear();
echo "清除后栈大小: " . ErrorHandlerTool::size() . "<br>";
echo $var7; // 被PHP内置处理器处理
// 7. 获取信息
$info = ErrorHandlerTool::info();
echo "<h4>处理器信息:</h4>";
echo "<pre>" . print_r($info, true) . "</pre>";在特定代码块中临时修改错误处理行为，执行完成后恢复原状
在多层函数调用中，每层可以有自己的错误处理器，通过restore_error_handler()逐层恢复
在try-finally或析构函数中确保错误处理器被正确恢复，避免资源泄漏
restore_error_handler()，通常是在try-finally块或对象析构函数中set_error_handler()会创建处理器栈，需要对应次数的restore_error_handler()调用才能恢复到原始状态false时，错误会传递给下一个处理器（或PHP内置处理器）。这与restore_error_handler()不同error_reporting()和display_errors等设置控制在设置临时错误处理器时，使用try-finally确保无论是否发生异常都能恢复：
$oldHandler = set_error_handler($newHandler);
try {
// 执行代码
} finally {
restore_error_handler();
}
创建包装函数来自动管理错误处理器的设置和恢复：
function withErrorHandler($handler, $callback) {
$old = set_error_handler($handler);
try {
return $callback();
} finally {
restore_error_handler();
}
}
在复杂的应用中，记录错误处理器的状态变化以便调试：
class ErrorHandlerLogger {
private $stack = [];
public function push($name) {
$old = set_error_handler([$this, $name]);
$this->stack[] = ['name' => $name, 'time' => microtime(true)];
return $old;
}
public function pop() {
array_pop($this->stack);
restore_error_handler();
}
}
只在真正需要时使用临时错误处理器，大多数情况应该使用单一的错误处理策略：
// 不好：频繁切换处理器
foreach ($items as $item) {
set_error_handler($handler);
process($item);
restore_error_handler();
}
// 好：一次性设置处理器
set_error_handler($handler);
foreach ($items as $item) {
process($item);
}
restore_error_handler();