一类会导致 Express 服务崩溃的错误

为了保证我们写的 Express 服务的稳定，一般我们都会对错误进行捕获和处理，让内部错误不至于使整个服务崩溃；但有时，使用常规的错误处理方法，也许还不能很好地应付程序中的错误。

Express 中如何进行错误处理

Express 默认会提供这样的错误处理，但如果我们需要自己定制对错误的处理方法，我们可以添加一个自定义 Error handler, 像下面这样：

const express = require('express')
const app = express()
const port = 8000
let count = 0;

app.get('/', (req, res, next) => {
  res.status(200).send('Hello world');

  count++;
  throw new Error(`${count}`);
})

// Error handler
app.use((err, req, res, next) => {
  console.log('Error: ', err.message);
});

app.listen(port, () => {
  console.log(`Example app listening on port ${port}`)
})

将我们的 Express 服务运行起来，并通过 8000 端口访问的话，上面的程序会正常返回 Hello world, 并在随后抛出一个错误；而由于我们写了自定义 Error handler, 我们的 Express 服务并不会崩溃，而是记录下这个 Error 的相关信息。

运行情况如下图所示, 可以看到错误都被捕获到了，并且 Express 服务依旧能正常响应：

有了 Error handler 就能捕获程序中所有的异常吗

我们对上述 Express 服务程序进行一些改动，如下：

const express = require('express')
const app = express()
const port = 8000
let count = 0;

app.get('/', (req, res, next) => {
  res.status(200).send('Hello world');

  count++;

  setTimeout(() => {
    throw new Error(`${count}`);
  }, 0);
})

// error handler
app.use((err, req, res, next) => {
  console.log('Error: ', err.message);
});

app.listen(port, () => {
  console.log(`Example app listening on port ${port}`)
})

查看运行结果，可以发现，这次一个错误让 Express 服务直接崩溃了，无法再响应后续请求：

原因就在于这次的错误是从异步函数里抛出的，而 Express 处理这样的错误需要额外的步骤，即错误需要传递给 next() 函数, 以下是官网的解释和例子：

因此，我们需要把我们的 Express 服务做如下修改，才能处理好这种异步函数中抛出的错误。

const express = require('express')
const app = express()
const port = 8000
let count = 0;

app.get('/', (req, res, next) => {
  res.status(200).send('Hello world');

  count++;

  setTimeout(() => {
    try {
      throw new Error(`${count}`);
    } catch (e) {
      next(e);
    }
  }, 0);
})

// error handler
app.use((err, req, res, next) => {
  console.log('Error: ', err.message);
});

app.listen(port, () => {
  console.log(`Example app listening on port ${port}`)
})

而实际开发中，异步函数可能会层层嵌套，如果其中某一层抛出的错误没有被传入 next() 函数，则也可能导致程序崩溃，如下例：

const express = require('express')
const app = express()
const port = 8000
let count = 0;

app.get('/', (req, res, next) => {
  res.status(200).send('Hello world');

  count++;

  setTimeout(() => {
    try {
      setTimeout(() => {
        throw new Error(`${count}`);
      }, 0);
    } catch (e) {
      next(e);
    }
  }, 0);
})

// error handler
app.use((err, req, res, next) => {
  console.log('Error: ', err.message);
});

app.listen(port, () => {
  console.log(`Example app listening on port ${port}`)
})

如何保证多层嵌套的异步函数里抛出的错误都能被传入 next() 函数呢

从上面的分析，我们知道，如果要妥善处理 Express 服务中的错误，我们就需要保证，所有异步函数里可能抛出的错误，都要被传入 next() 函数。

而当异步函数嵌套层级变多时，如果将 next() 函数作为参数，层层传入异步函数，这样会写很多的 next() 函数调用；并且这种方式与嵌套结构高度耦合，不利于代码重构。

下例可以看出这种方法的问题——要给每个异步函数都需要传递一个 next 参数，而这个参数对于完成该函数自身逻辑没有帮助，显得冗余。

function asyncFunc1(next) {
  try {
    // Do some synchronized logic...
    asyncFunc2(next);
  } catch (e) {
    next(e);
  }
}

function asyncFunc2(next) {
  try {
    // Do some synchronized logic...
    asyncFunc3(next);
  } catch (e) {
    next(e);
  }
}

function asyncFunc3(next) {
  setTimeout(() => {
    try {
      throw new Error('asyncFunc3 Error');
    } catch (e) {
      next(e);
    }
  }, 0);
}

app.get('/', (req, res, next) => {
  res.status(200).send('Hello world');

  asyncFunc1(next);
})

这里我希望所有异步函数的错误都可以被抛到最外层，由外层统一调用 next() 函数处理。

借助 Promise 可以实现这个目标。例如目前 NodeJS 的文件系统等操作，都提供了相应的 Promises API；类似地，我们可以让我们的异步函数返回一个 Promise，所有内部错误均通过这个 Promise 的 reject 状态得到。

请看下例 (注：我们目前只关心错误处理，所以省略了Promise resolve 状态的处理)：

function asyncFunc1() {
  return new Promise((resolve, reject) => {
    try {
      // Do some synchronized logic...
      asyncFunc2().catch((e) => {
        reject(e);
      });
    } catch (e) {
      reject(e);
    }
  })
}

function asyncFunc2() {
  return new Promise((resolve, reject) => {
    try {
      // Do some synchronized logic...
      asyncFunc3().catch((e) => {
        reject(e);
      });
    } catch (e) {
      reject(e);
    }
  })
}

function asyncFunc3() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      try {
        throw new Error('asyncFunc3 Error');
      } catch (e) {
        reject(e);
      }
    }, 0);
  })
}

app.get('/', (req, res, next) => {
  res.status(200).send('Hello world');

  asyncFunc1().catch((e) => {
    next(e);
  })
})

像这样，通过异步函数返回的 Promise 的状态，我们就可以对抛出的错误统一在最外层进行处理，而不需要给每个异步函数传递它不需要的参数。

总结

写 Express 服务的时候，要特别注意对异步函数中发生的错误的处理，如果异步函数中产生的错误，没有被传入 next() 函数，Express 中的 Error handler 就没法对其进行处理，从而导致服务崩溃。

为了更好地捕获异步函数中产生的错误，推荐在实现异步函数时，使其返回 Promise 对象。

如果使用无法返回 Promise 对象的第三方异步函数，可以考虑自行封装。