Eine kurze Analyse der Fehlerbehandlungs-Middleware von Express in Node

Dieser Artikel führt Sie durch die Fehlerbehandlungs-Middleware von Express in Node und stellt die Methode zur Definition der Fehlerbehandlungs-Middleware und deren Verwendung mit async/await vor. Ich hoffe, dass er für alle hilfreich ist!

Die Fehlerbehandlungs-Middleware von Express hilft Ihnen, mit Fehlern umzugehen, ohne die gleiche Arbeit wiederholen zu müssen. Angenommen, Sie behandeln Fehler direkt im Express-Route-Handler:

app.put('/user/:id', async (req, res) => {
  let user
  try {
    user = await User.findOneAndUpdate({ _id: req.params.id }, req.body)
  } catch (err) {
    return res.status(err.status || 500).json({ message: err.message })
  }
  return res.json({ user })
})

Der obige Code funktioniert gut, aber wenn es Hunderte von Schnittstellen gibt, wird die Fehlerbehandlungslogik nicht mehr zu warten, da sie hunderte Male wiederholt wird.

Middleware zur Fehlerbehandlung definieren

Express ist entsprechend der Anzahl der von der Middleware-Funktion verwendeten Parameter in verschiedene Typen unterteilt. Die Middleware-Funktion, die 4 Parameter akzeptiert, ist als „Fehlerbehandlungs-Middleware“ definiert und wird nur aufgerufen, wenn ein Fehler auftritt.

const app = require('express')()

app.get('*', function routeHandler() {
  // 此中间件抛出一个错误，Express 将直接转到下一个错误处理程序
  throw new Error('Oops!')
})

app.get('*', (req, res, next) => {
  // 此中间件不是错误处理程序（只有3个参数），Express 将跳过它，因为之前的中间件中存在错误
  console.log('这里不会打印')
})

// 您的函数必须接受 4 个参数，以便 Express 将其视为错误处理中间件。
app.use((err, req, res, next) => {
  res.status(500).json({ message: err.message })
})

Express behandelt automatisch Synchronisierungsfehler für Sie, wie z. B. die obige Methode routeHandler(). Express verarbeitet jedoch keine asynchronen Fehler. Wenn ein asynchroner Fehler auftritt, muss next() aufgerufen werden.

const app = require('express')()

app.get('*', (req, res, next) => {
  // next() 方法告诉 Express 转到链中的下一个中间件。
  // Express 不处理异步错误，因此您需要通过调用 next() 来报告错误。
  setImmediate(() => {
    next(new Error('Oops'))
  })
})

app.use((err, req, res, next) => {
  res.status(500).json({
    message: err.message
  })
})

Bitte denken Sie daran, dass die Express-Middleware sequentiell ausgeführt wird. Sie sollten Fehlerhandler zuletzt definieren, nach allen anderen Middleware. Andernfalls wird Ihr Fehlerhandler nicht aufgerufen: routeHandler() 方法。但是 Express 不处理异步错误。如果出现异步错误，则需要调用 next()。

const app = require('express')()

app.get('*', (req, res, next) => {
  // 报告异步错误必须通过 next()
  return new Promise((resolve, reject) => {
    setImmediate(() => reject(new Error('woops')))
  }).catch(next)
})

app.use((error, req, res, next) => {
  console.log('will not print')
  res.json({ message: error.message })
})

app.listen(3000)

请记住，Express 中间件是按顺序执行的。您应该在所有其他中间件之后，最后定义错误处理程序。否则，您的错误处理程序将不会被调用：

与 async/await 一起使用

Express 无法捕获 promise 的异常，Express 在 ES6 之前编写，对于如何处理 async/await 它扔没有好的解决方案。

例如，下面的服务器永远不会成功发送 HTTP 响应，因为 Promise reject 永远不会得到处理：

function wrapAsync(fn) {
  return function(req, res, next) {
    fn(req, res, next).catch(next)
  }
}

app.get('*', wrapAsync(async (req, res) => {
  await new Promise(resolve => setTimeout(() => resolve(), 50))
  // Async error!
  throw new Error('woops')
}))

我们可以封装或者使用现有的库来进行捕获。

首先，我们先简单封装一个函数，将 async/await 与 Express 错误处理中间件联系起来。

注意：异步函数会返回 Promise，因此您需要确保 catch() 所有错误并将其传递给 next()。

require('express-async-errors')
app.get('*', async (req, res, next) => {
  await new Promise((resolve) => setTimeout(() => resolve(), 50))
  throw new Error('woops')
})

使用第三方库 express-async-errors，一个简单的 ES6 async/await 支持 hack：

rrreee

最后

Express 错误处理中间件允许您以最大化关注点分离的方式处理错误。您不需要处理业务逻辑中的错误，如果使用 async/await，甚至不需要 try/catch

Verwendung mit async/await

Express kann promise-Code> nicht abfangen Ausnahme: Express wurde vor ES6 geschrieben und es gibt keine gute Lösung für den Umgang mit async/await, den es auslöst. Zum Beispiel wird der folgende Server die HTTP-Antwort nie erfolgreich senden, da das Promise reject nie verarbeitet wird:

rrreee🎜Wir können die Erfassung kapseln oder eine vorhandene Bibliothek verwenden. 🎜🎜Zuerst kapseln wir einfach eine Funktion, um async/await mit der Express-Fehlerbehandlungs-Middleware zu verbinden. 🎜

🎜🎜Hinweis🎜: Asynchrone Funktionen geben Promise zurück, Sie müssen also sicherstellen, dass alle Fehler catch() sind und an next() übergeben werden. 🎜

rrreee🎜Verwenden Sie Bibliotheken von Drittanbietern express-async-errors🎜, ein einfacher ES6-Async/Await-Support-Hack: 🎜rrreee

Endlich 🎜🎜Express-Fehlerbehandlungs-Middleware ermöglicht Sie können mit Fehlern auf eine Art und Weise umgehen, die eine größtmögliche Trennung der Anliegen ermöglicht. Sie müssen keine Fehler in Ihrer Geschäftslogik behandeln oder sogar try/catch, wenn Sie async/await verwenden. Diese Fehler werden in Ihrem Fehlerbehandler angezeigt, der dann entscheiden kann, wie auf die Anfrage reagiert wird. Nutzen Sie diese leistungsstarke Funktion unbedingt in Ihrer nächsten Express-App! 🎜🎜Weitere Informationen zu Knoten finden Sie unter: 🎜nodejs-Tutorial🎜! 🎜

Das obige ist der detaillierte Inhalt vonEine kurze Analyse der Fehlerbehandlungs-Middleware von Express in Node. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!