Analyse des types d'erreurs personnalisés sous Node.js

Cet article vous donne une introduction détaillée sur la façon de personnaliser les types d'erreurs sous Node.js. Il a une certaine valeur de référence pour que tout le monde puisse apprendre ou utiliser Node.js. Les amis dans le besoin peuvent s'y référer. Jetez un oeil.

Préface

De manière générale, peu de gens envisageront simplement la stratégie de gestion des erreurs générées par les applications pendant le processus de débogage. Utiliser console.log(‘error') pour localiser les erreurs est fondamentalement suffisant. En laissant ces informations de débogage, cela peut nous faire gagner beaucoup de temps dans le futur processus de débogage et améliorer la maintenabilité. Les messages d’erreur sont donc très importants. Dans le même temps, cela entraînera également une mauvaise utilisation. Des types d'erreur personnalisés ont été utilisés dans des projets récents, et j'ai estimé qu'il était nécessaire d'en savoir plus à leur sujet. J'ai donc écrit cet article pour permettre à moi-même et à tous ceux qui en ont besoin de s'y référer plus facilement en cas de besoin.

Erreur de sous-classe

Nous pouvons d'abord définir une sous-classe d'Erreur. Il est facile à mettre en œuvre via Object.create et util.inherits  :

var assert = require('assert');
var util = require('util');

function NotFound(msg){
 Error.call(this);
 this.message = msg;
}
util.inherits(NotFound, Error);
var error = new NotFound('not found');
assert(error.message);
assert(error instanceof NotFound);
assert(error instanceof Error);
assert.equal(error instanceof RangeError, false);

Vous pouvez utiliser instanceof pour vérifier le type d'erreur et effectuer différents traitements selon le genre.

Le code ci-dessus définit le message intégré, et error est une instance de NotFound et Error , mais pas RangeError.

Si vous utilisez le framework express , vous pouvez configurer d'autres properties pour rendre error plus utile.

Par exemple, lors du traitement d'une erreur HTTP, cela peut s'écrire ainsi :

function NotFound(msg) {
 Error.call(this);
 this.message = msg;
 this.statusCode = 404;
}

Il est désormais possible de gérer les messages d'erreur via un middleware de gestion des erreurs :

app.use(function(err, req, res, next) {
 console.error(err.stack);

 if (!err.statusCode || err.statusCode === 500) {
 emails.error({ err: err, req: req });
 }

 res.send(err.statusCode || 500, err.message);
});

Cela enverra le code d'état HTTP au navigateur, lorsque le err de statusCode n'est pas défini ou égal à 500, cette erreur sera envoyée par email. Cela éliminera ces erreurs 404, 401, 403, etc.

la lecture de console.error(err.stack) ne fonctionne pas réellement comme prévu, comme Node, Chrome basé sur V8 peut utiliser le mauvais constructeur de Error.captureStackTrace(this, arguments.callee) pour les traces de pile.

var NotFound = function(msg) {
 Error.call(this);
 Error.captureStackTrace(this, arguments.callee);
 this.message = msg || 'Not Found';
 this.statusCode = 404;
 this.name = "notFound"
}
util.inherits(NotFound, Error);

export.NotFoundError = NotFound;

Bien sûr, nous pouvons également étendre le type d'erreur abstraite créé ci-dessus à d'autres erreurs personnalisées :

var notFountError = require('./error').NotFountError; 
var UserNotFound = function(msg){
 this.constructor.super_(msg);
}

util.inherits(UserNotFound, notFoundError);

Ce qui précède est l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'étude de chacun. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois !

Recommandations associées :

Introduction aux définitions de modules dans nodejs

Méthode de Nodejs pour implémenter le chargement asynchrone bigpipe des pages

À propos de la méthode node.js de lecture et d'écriture de fichiers et répertoires système basée sur le module fs

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!