Eine kurze Analyse der Fehlerbehandlungs-Middleware von Express in Node

So starten Sie schnell mit VUE3.0:

Die Fehlerbehandlungs-Middleware von Learn Express kann Ihnen dabei helfen, 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) => {
  Benutzer lassen
  versuchen {
    user = wait User.findOneAndUpdate({ _id: req.params.id }, req.body)
  } fangen (irrt) {
    return res.status(err.status || 500).json({ message: err.message })
  }
  return res.json({user})
})

Der obige Code funktioniert einwandfrei. Wenn es jedoch Hunderte von Schnittstellen gibt, wird die Fehlerbehandlungslogik nicht mehr wartbar, da sie Hunderte Male wiederholt wird.

Definieren der Fehlerbehandlungs-Middleware

Express wird entsprechend der Anzahl der Parameter, die die Middleware-Funktion benötigt, 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() {
  // Diese Middleware löst einen Fehler aus und Express geht direkt zum nächsten Fehlerhandler über. throw new Error('Ups!')
})

app.get('*', (req, res, next) => {
  // Diese Middleware ist kein Fehlerbehandler (nur 3 Parameter). Express überspringt sie, da in der vorherigen Middleware ein Fehler vorliegt console.log('Dies wird nicht gedruckt')
})

// Ihre Funktion muss 4 Parameter akzeptieren, damit Express sie als Fehlerbehandlungs-Middleware behandeln kann.
app.use((err, req, res, next) => {
  res.status(500).json({ message: err.message })
})

Express behandelt Synchronisierungsfehler automatisch für Sie, wie zum Beispiel 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) => {
  // Die Methode next() weist Express an, zur nächsten Middleware in der Kette zu wechseln.
  // Express verarbeitet keine asynchronen Fehler, daher müssen Sie Fehler durch Aufruf von next() melden.
  setImmediate(() => {
    next(new Error('Ups'))
  })
})

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

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:

async/await

Express mit async/await kann keine Ausnahmen von promise abfangen. Express wurde vor ES6 geschrieben und es gibt keine gute Lösung für den Umgang async/await das es auslöst.

Beispielsweise sendet der folgende Server die HTTP-Antwort nie erfolgreich, da die Promise- reject nie behandelt wird:

const app = require('express')()

app.get('*', (req, res, next) => {
  // Das Melden asynchroner Fehler muss weitergegeben werden (next())
  neues Versprechen zurückgeben((auflösen, ablehnen) => {
    setImmediate(() => Reject(new Error('woops')))
  }).catch(next)
})

app.use((error, req, res, next) => {
  console.log('wird nicht gedruckt')
  res.json({ message: error.message })
})

app.listen(3000)

oder eine vorhandene Bibliothek zum Erfassen 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 daher sicherstellen, dass alle Fehler catch() und an next() übergeben werden.

Funktion wrapAsync(fn) {
  Rückgabefunktion(req, res, next) {
    fn(req, res, next).catch(next)
  }
}

app.get('*', wrapAsync(async (req, res) => {
  warte auf neues Versprechen(resolve => setTimeout(() => discover(), 50))
  // Async-Fehler!
  wirf einen neuen Fehler ('woops')
}))

Verwenden Sie die Drittanbieter-Bibliothek express-async-errors , einen einfachen ES6-Async/Await-Support-Hack:

require('express-async-errors')
app.get('*', async (req, res, next) => {
  Warten auf neues Versprechen((resolve) => setTimeout(() => discover(), 50))
  wirf einen neuen Fehler ('woops')
})

Schließlich

ermöglicht Ihnen die Express-Fehlerbehandlungs-Middleware, Fehler so zu behandeln, dass die Trennung von Bedenken maximiert wird. Sie müssen keine Fehler in Ihrer Geschäftslogik behandeln, nicht einmal 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!