Une brève analyse du middleware de gestion des erreurs d'Express dans Node

Comment démarrer rapidement avec VUE3.0 :

le middleware de gestion des erreurs de Learn Express peut vous aider à gérer les erreurs sans répéter le même travail. En supposant que vous gérez les erreurs directement dans le gestionnaire de route Express :

app.put('/user/:id', async (req, res) => {
  laisser l'utilisateur
  essayer {
    utilisateur = attendre User.findOneAndUpdate({ _id : req.params.id }, req.body)
  } attraper (erreur) {
    return res.status(err.status || 500).json({ message : err.message })
  }
  retourner res.json({utilisateur})
})

Le code ci-dessus fonctionne bien, cependant, que se passe-t-il s'il y a des centaines d'interfaces, alors la logique de gestion des erreurs devient impossible à maintenir car elle est répétée des centaines de fois.

Définition du middleware de gestion des erreurs

Express est divisé en différents types en fonction du nombre de paramètres pris par la fonction middleware. La fonction middleware qui accepte 4 paramètres est définie comme middleware de gestion des erreurs et ne sera appelée que lorsqu'une erreur se produit.

const app = require('express')()

app.get('*', fonction routeHandler() {
  // Ce middleware renvoie une erreur et Express ira directement au prochain gestionnaire d'erreurs et lancera une nouvelle erreur ('Oups !')
})

app.get('*', (req, res, suivant) => {
  // Ce middleware n'est pas un gestionnaire d'erreurs (seulement 3 paramètres), Express l'ignorera car il y a une erreur dans le middleware précédent console.log('Ceci ne sera pas imprimé')
})

// Votre fonction doit accepter 4 paramètres pour qu'Express la traite comme un middleware de gestion des erreurs.
app.use((err, req, res, next) => {
  res.status(500).json({ message : err.message })
})

Express gérera automatiquement les erreurs de synchronisation pour vous, comme routeHandler() ci-dessus. Mais Express ne gère pas les erreurs asynchrones. Si une erreur asynchrone se produit, next() doit être appelé.

const app = require('express')()

app.get('*', (req, res, suivant) => {
  // La méthode next() indique à Express de passer au middleware suivant de la chaîne.
  // Express ne gère pas les erreurs asynchrones, vous devez donc signaler les erreurs en appelant next().
  setImmediate(() => {
    suivant(nouvelle erreur('Oups'))
  })
})

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

N'oubliez pas que le middleware Express est exécuté de manière séquentielle. Vous devez définir les gestionnaires d'erreurs en dernier, après tous les autres middlewares. Sinon, votre gestionnaire d'erreurs ne sera pas appelé :

async/await

Express avec async/await ne peut pas détecter les exceptions des promise , Express a été écrit avant ES6 et il n'y a pas de bonne solution pour gérer async/await qu'il lance.

Par exemple, le serveur suivant n'envoie jamais correctement la réponse HTTP car le reject de la promesse n'est jamais géré :

const app = require('express')()

app.get('*', (req, res, suivant) => {
  // Le rapport des erreurs asynchrones doit passer next()
  renvoyer une nouvelle promesse ((résoudre, rejeter) => {
    setImmediate(() => rejeter(nouvelle erreur('woops')))
  }).catch(suivant)
})

app.use((erreur, req, res, suivant) => {
  console.log('ne s'imprimera pas')
  res.json({ message : erreur.message })
})

app.listen(3000)

ou utiliser une bibliothèque existante pour capturer.

Tout d’abord, nous encapsulons simplement une fonction pour connecter async/await avec le middleware de gestion des erreurs Express.

REMARQUE : les fonctions asynchrones renvoient Promise, vous devez donc vous assurer de catch() toutes les erreurs et de les transmettre à next() .

fonction wrapAsync(fn) {
  fonction de retour (req, res, suivant) {
    fn(req, res, suivant).catch(suivant)
  }
}

app.get('*', wrapAsync(async (req, res) => {
  attendre une nouvelle promesse (resolve => setTimeout (() => solve (), 50))
  // Erreur asynchrone !
  lancer une nouvelle erreur('woops')
}))

Utilisez la bibliothèque tierce express-async-errors , un simple hack de support ES6 async/await :

require('express-async-errors')
app.get('*', async (req, res, next) => {
  attendre une nouvelle promesse ((resolve) => setTimeout (() => solve (), 50))
  lancer une nouvelle erreur('woops')
})

Enfin,

le middleware de gestion des erreurs Express vous permet de gérer les erreurs de manière à maximiser la séparation des problèmes. Vous n'avez pas besoin de gérer les erreurs dans votre logique métier, pas même try/catch si vous utilisez async/await . Ces erreurs apparaîtront dans votre gestionnaire d'erreurs, qui pourra alors décider comment répondre à la demande. Assurez-vous de profiter de cette fonctionnalité puissante dans votre prochaine application Express !