Node.js 实现全局错误处理器的几种方式

1. 使用 `process.on('uncaughtException')`

在 Node.js 中，process.on('uncaughtException') 是一种简单且常用的捕获未处理异常的方式。当一个异常在事件循环中没有被任何 try - catch 块捕获时，就会触发 uncaughtException 事件。

1.1 基本原理

process 是 Node.js 中的一个全局对象，代表了当前的 Node.js 进程。uncaughtException 事件是 process 对象上的一个事件，一旦有未捕获的异常，Node.js 会暂停正常的执行流，然后触发这个事件。

1.2 代码示例

process.on('uncaughtException', (err) => {
    console.log('捕获到未处理的异常:', err.message);
    console.log('异常堆栈信息:', err.stack);
});

// 抛出一个未捕获的异常
function throwError() {
    throw new Error('这是一个故意抛出的未捕获异常');
}

throwError();

在上述代码中，我们定义了一个 throwError 函数，它会抛出一个新的 Error 实例。由于这个异常没有被 try - catch 块捕获，process.on('uncaughtException') 回调函数中的代码就会被执行。

1.3 优点

简单直接：只需添加一行 process.on('uncaughtException') 代码，就可以全局捕获未处理的异常。对于快速搭建一个基本的错误处理机制非常方便。
即时响应：一旦异常发生，立即触发事件并执行相应的处理逻辑。

1.4 缺点

进程可能继续运行：即使捕获到了异常，Node.js 进程默认情况下不会退出（除非手动调用 process.exit()）。这可能导致进程处于不稳定状态，因为在发生未处理异常后，程序的状态可能已经不可预期，继续运行可能会导致更多的错误。
不能捕获异步错误：例如在 setTimeout 或 Promise 中抛出的异步错误，uncaughtException 无法捕获。

2. 使用 `process.on('unhandledRejection')` 处理 Promise 拒绝

随着异步编程在 Node.js 中的广泛应用，Promise 被大量使用。当一个 Promise 被拒绝（rejected）且没有被 .catch() 处理时，就需要一种机制来全局捕获这些未处理的拒绝。

2.1 基本原理

process.on('unhandledRejection') 事件在一个 Promise 被拒绝且没有被 .catch() 块处理时触发。Node.js 会将这个被拒绝的 Promise 和拒绝原因传递给注册的回调函数。

2.2 代码示例

process.on('unhandledRejection', (reason, promise) => {
    console.log('捕获到未处理的 Promise 拒绝:', reason.message);
    console.log('被拒绝的 Promise:', promise);
});

function rejectPromise() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            reject(new Error('这是一个故意拒绝的 Promise'));
        }, 1000);
    });
}

rejectPromise();

在这个示例中，rejectPromise 函数返回一个 Promise，它会在 1 秒后被拒绝。由于没有使用 .catch() 处理这个拒绝，process.on('unhandledRejection') 的回调函数就会被调用。

2.3 优点

针对性强：专门用于处理 Promise 相关的未处理拒绝，为基于 Promise 的异步代码提供了有效的全局错误处理方式。
不影响进程稳定性：与 uncaughtException 不同，unhandledRejection 事件不会影响 Node.js 进程的正常执行流，它只是提供一个机会来记录错误或者采取一些补救措施。

2.4 缺点

仅处理 Promise 拒绝：只能捕获 Promise 被拒绝且未被处理的情况，对于其他类型的错误（如同步错误或基于回调的异步错误）无能为力。

3. 使用 Domain 模块（已弃用）

在 Node.js v0.8 版本引入了 Domain 模块，它提供了一种将多个不同的异步操作作为一个组来处理错误的方式，从而实现全局错误处理。然而，从 Node.js v14 版本开始，Domain 模块被标记为弃用，建议使用其他替代方案。

3.1 基本原理

Domain 模块允许你创建一个域对象，将多个异步操作（如 setTimeout、fs.readFile 等）绑定到这个域中。当在这些异步操作中抛出未捕获的异常时，域对象可以捕获并处理这些异常，而不会导致进程崩溃。

3.2 代码示例

const domain = require('domain');
const fs = require('fs');

const myDomain = domain.create();

myDomain.on('error', (err) => {
    console.log('域捕获到错误:', err.message);
    console.log('错误堆栈信息:', err.stack);
});

myDomain.run(() => {
    fs.readFile('nonexistentfile.txt', 'utf8', (err, data) => {
        if (err) {
            throw err;
        }
        console.log(data);
    });
});

在上述代码中，我们创建了一个 Domain 对象 myDomain，并在 myDomain 上注册了一个 error 事件处理函数。然后，我们在 myDomain.run() 中执行一个异步文件读取操作。如果在这个操作中抛出错误，myDomain 的 error 事件处理函数就会捕获并处理这个错误。

3.3 优点

统一管理异步错误：能够将多个异步操作集中管理，在一个地方处理它们可能抛出的错误，避免了在每个异步操作中单独编写错误处理代码。
灵活的错误处理：可以根据不同的业务逻辑，在域对象中进行更复杂的错误处理，如记录错误日志、进行资源清理等。

3.4 缺点

已弃用：从 Node.js v14 开始被标记为弃用，未来版本可能不再支持，使用它会导致代码的可维护性和兼容性问题。
复杂性：相比其他方式，使用 Domain 模块需要更多的代码和概念理解，增加了代码的复杂性。

4. 使用 Async_hooks 模块（高级）

Async_hooks 模块是 Node.js v8.0.0 引入的一个高级模块，它提供了一种追踪异步资源生命周期的方式，通过这种方式可以实现更细粒度和强大的全局错误处理。

4.1 基本原理

Async_hooks 模块允许你注册回调函数，在异步资源的创建、激活、停用和销毁等生命周期阶段被调用。通过这些回调函数，我们可以追踪异步操作的执行流程，并在异步操作中捕获未处理的异常。

4.2 代码示例

const async_hooks = require('async_hooks');
const { executionAsyncId } = async_hooks;

const asyncHook = async_hooks.createHook({
    init(asyncId, type, triggerAsyncId) {
        // 异步资源初始化时调用
    },
    before(asyncId) {
        // 异步资源执行前调用
    },
    after(asyncId) {
        // 异步资源执行后调用
    },
    destroy(asyncId) {
        // 异步资源销毁时调用
    },
    promiseResolve(asyncId) {
        // Promise 被解决时调用
    }
});

asyncHook.enable();

function asyncFunction() {
    setTimeout(() => {
        try {
            throw new Error('这是一个在 setTimeout 中抛出的错误');
        } catch (err) {
            const currentAsyncId = executionAsyncId();
            console.log('捕获到错误，当前异步资源 ID:', currentAsyncId);
            console.log('错误信息:', err.message);
            console.log('错误堆栈:', err.stack);
        }
    }, 1000);
}

asyncFunction();

在上述代码中，我们使用 async_hooks.createHook 创建了一个 AsyncHook 对象，并注册了多个生命周期回调函数。在 asyncFunction 函数中，我们在 setTimeout 中故意抛出一个错误，并在 try - catch 块中捕获它。通过 executionAsyncId() 我们可以获取当前异步操作的唯一标识符，以便更详细地追踪错误。

4.3 优点

细粒度控制：可以深入到异步资源的生命周期各个阶段，实现非常细粒度的错误追踪和处理，对于复杂的异步应用程序非常有用。
全面的异步错误捕获：不仅可以捕获传统的异步回调中的错误，还能处理 Promise 等各种异步操作中的错误。

4.4 缺点

复杂性高：Async_hooks 模块的使用需要对异步编程和 Node.js 内部机制有较深入的理解，代码编写和维护难度较大。
性能开销：由于需要追踪异步资源的生命周期，会带来一定的性能开销，在性能敏感的应用中需要谨慎使用。

5. 使用 Express 中间件进行错误处理（适用于 Web 应用）

如果你的 Node.js 应用是基于 Express 框架构建的 Web 应用，那么可以利用 Express 的中间件机制来实现全局错误处理。

5.1 基本原理

Express 中间件是一个函数，它可以访问请求对象（req）、响应对象（res）和应用程序的 next 函数。通过定义错误处理中间件，我们可以捕获在路由处理函数和其他中间件中抛出的错误。

5.2 代码示例

const express = require('express');
const app = express();

// 模拟一个会抛出错误的路由
app.get('/error', (req, res, next) => {
    throw new Error('这是一个在路由中抛出的错误');
});

// 全局错误处理中间件
app.use((err, req, res, next) => {
    console.log('Express 捕获到错误:', err.message);
    console.log('错误堆栈信息:', err.stack);
    res.status(500).send('服务器内部错误');
});

const port = 3000;
app.listen(port, () => {
    console.log(`服务器在端口 ${port} 上运行`);
});

在这个示例中，我们定义了一个 /error 路由，它会抛出一个错误。然后，我们定义了一个全局错误处理中间件 app.use((err, req, res, next) => {...})。当路由处理函数中抛出错误时，Express 会将错误传递给这个中间件进行处理。

5.3 优点

与 Express 集成良好：非常适合基于 Express 框架的 Web 应用，利用 Express 已有的中间件机制，代码简洁且易于维护。
可以定制响应：可以根据不同的错误类型，向客户端返回不同的 HTTP 状态码和错误信息，提供更好的用户体验。

5.4 缺点

仅适用于 Express 应用：如果应用不是基于 Express 框架构建的，这种方式就无法使用。
局限于 HTTP 请求处理：只能捕获在 Express 路由和中间件中与 HTTP 请求处理相关的错误，对于应用程序其他部分（如独立的异步任务）的错误无法捕获。

6. 使用 Try - Catch 块封装异步操作

虽然这不是严格意义上的全局错误处理方式，但通过在异步操作外部使用 try - catch 块，可以有效地捕获异步操作中抛出的错误，并且在一定程度上模拟全局错误处理的效果。

6.1 基本原理

对于基于回调的异步函数，可以将其包装在一个自执行函数中，并在这个自执行函数内部使用 try - catch 块。对于 Promise，可以使用 .catch() 方法来捕获拒绝。

6.2 代码示例

基于回调的异步函数

const fs = require('fs');

function readFileWithErrorHandling(filePath) {
    try {
        fs.readFile(filePath, 'utf8', (err, data) => {
            if (err) {
                throw err;
            }
            console.log(data);
        });
    } catch (err) {
        console.log('捕获到错误:', err.message);
        console.log('错误堆栈信息:', err.stack);
    }
}

readFileWithErrorHandling('nonexistentfile.txt');

基于 Promise 的异步函数

function readFileAsync(filePath) {
    return new Promise((resolve, reject) => {
        fs.readFile(filePath, 'utf8', (err, data) => {
            if (err) {
                reject(err);
            } else {
                resolve(data);
            }
        });
    });
}

readFileAsync('nonexistentfile.txt')
   .catch((err) => {
        console.log('捕获到错误:', err.message);
        console.log('错误堆栈信息:', err.stack);
    });

在上述基于回调的示例中，我们将 fs.readFile 包装在 try - catch 块中。在基于 Promise 的示例中，我们使用 .catch() 方法来捕获 Promise 被拒绝时的错误。

6.3 优点

简单易懂：对于熟悉 try - catch 和 Promise 的开发者来说，这种方式非常直观，易于实现和理解。
可针对性处理：可以根据不同的异步操作，定制不同的错误处理逻辑，而不会影响其他异步操作。

6.4 缺点

代码冗余：如果有大量的异步操作，需要在每个异步操作处都添加 try - catch 或 .catch()，会导致代码冗余。
非真正全局：这不是一种全局的错误处理方式，对于新添加的异步操作，可能会忘记添加错误处理代码，导致错误未被捕获。

7. 使用自定义错误类和错误处理函数

通过定义自定义错误类和全局的错误处理函数，可以实现一种灵活且可扩展的全局错误处理方式。

7.1 基本原理

首先定义自定义错误类，继承自内置的 Error 类，以便在不同的业务场景下抛出特定类型的错误。然后，创建一个全局的错误处理函数，在应用程序的各个部分调用这个函数来处理错误。

7.2 代码示例

// 定义自定义错误类
class MyCustomError extends Error {
    constructor(message) {
        super(message);
        this.name = 'MyCustomError';
    }
}

// 全局错误处理函数
function handleError(err) {
    console.log('捕获到错误，错误类型:', err.name);
    console.log('错误信息:', err.message);
    console.log('错误堆栈信息:', err.stack);
}

// 模拟抛出自定义错误
function throwCustomError() {
    throw new MyCustomError('这是一个自定义错误');
}

try {
    throwCustomError();
} catch (err) {
    handleError(err);
}

在上述代码中，我们定义了 MyCustomError 类，继承自 Error 类。然后，定义了 handleError 函数来统一处理错误。在 throwCustomError 函数中抛出一个自定义错误，并在 try - catch 块中调用 handleError 函数来处理这个错误。

7.3 优点

灵活性和扩展性：可以根据业务需求定义不同类型的自定义错误类，并且通过全局的错误处理函数，可以在一个地方对所有错误进行统一处理，方便添加新的错误处理逻辑。
代码清晰：自定义错误类使得错误类型更加明确，有助于代码的维护和调试。

7.4 缺点

手动调用：需要在每个可能抛出错误的地方手动使用 try - catch 块，并调用全局错误处理函数，对于大型应用程序可能会遗漏一些地方。
依赖于代码规范：要求开发者严格按照定义的错误处理方式来编写代码，如果有部分代码没有遵循规范，可能会导致错误未被正确处理。

8. 使用第三方库如 Sentry

Sentry 是一个流行的错误监控和报告平台，它提供了 Node.js 客户端库，可以方便地集成到 Node.js 应用程序中，实现强大的全局错误处理和监控功能。

8.1 基本原理

Sentry 的 Node.js 客户端会捕获应用程序中的未处理异常和未处理的 Promise 拒绝，并将这些错误信息发送到 Sentry 服务器。Sentry 服务器会对错误进行分析、聚合，并提供详细的错误报告和监控功能。

8.2 代码示例

首先，需要安装 Sentry 的 Node.js 客户端库：

npm install @sentry/node

然后，在应用程序入口文件中初始化 Sentry：

const Sentry = require('@sentry/node');
Sentry.init({
    dsn: 'YOUR_DSN_HERE'
});

// 模拟一个会抛出错误的函数
function throwError() {
    throw new Error('这是一个故意抛出的错误');
}

try {
    throwError();
} catch (err) {
    Sentry.captureException(err);
}

在上述代码中，我们首先通过 Sentry.init() 初始化 Sentry，其中 dsn 是 Sentry 提供的数据源名称。然后，在 try - catch 块中捕获错误，并使用 Sentry.captureException(err) 将错误发送到 Sentry 服务器。

8.3 优点

强大的错误监控：Sentry 提供了丰富的错误分析和聚合功能，可以帮助开发者快速定位和解决问题。它可以追踪错误的发生频率、影响范围等信息。
易于集成：只需简单的几步配置，就可以将 Sentry 集成到 Node.js 应用程序中，实现全局错误处理和监控。

8.4 缺点

依赖外部服务：需要依赖 Sentry 服务器来处理和存储错误信息，如果 Sentry 服务器出现故障或者网络问题，可能会影响错误监控功能。
成本：对于一些大型应用或者需要高级功能的场景，可能需要购买 Sentry 的付费版本，存在一定的成本。

通过以上几种方式，可以在 Node.js 应用程序中实现不同程度和类型的全局错误处理，开发者可以根据应用程序的特点和需求选择合适的方式来确保应用程序的稳定性和可靠性。