Créer un système de gestion des erreurs simple et efficace dans Node.js

Lors de la création d’applications Web, les choses ne se passent pas toujours comme prévu. Les utilisateurs peuvent tenter des opérations non valides, des données peuvent être manquantes ou des bogues inattendus peuvent survenir. La gestion gracieuse de ces erreurs est essentielle pour créer une application fiable et offrir une bonne expérience utilisateur.

Dans cet article, je vais vous montrer comment implémenter un système de gestion des erreurs simple et efficace dans votre application Node.js. Allons-y ! ?

Les bases de la gestion des erreurs

En JavaScript, une erreur est généralement représentée comme une instance de la classe Error. Lorsque quelque chose ne va pas, vous pouvez « générer » une erreur et votre application peut la détecter pour répondre en conséquence. Cependant, dans les applications plus volumineuses, la gestion des erreurs avec uniquement la classe Error de base peut s'avérer compliquée.

C'est là que les classes d'erreur personnalisées sont utiles !
Création d'une classe d'erreur personnalisée

Voici une classe appelée AppError que nous pouvons utiliser pour définir des erreurs structurées et significatives :

export class AppError extends Error {
    constructor(name, httpCode, description, isOperational, errors = []) {
        super(description); // Call the parent class (Error) constructor
        this.name = name; // Name of the error (e.g., ValidationError)
        this.httpCode = httpCode; // HTTP status code (e.g., 400, 404, 500)
        this.isOperational = isOperational; // Flag to distinguish between operational and system errors
        this.errors = errors; // Optional array of detailed error messages
    }
}

Comment ça marche ?

• nom : décrit le type d'erreur, comme ValidationError ou NotFoundError.
• httpCode : définit un code d'état HTTP approprié, tel que 400 pour les requêtes incorrectes ou 500 pour les erreurs du serveur.
• description : fournit un message convivial décrivant l'erreur.
• isOperational : un indicateur booléen pour indiquer si l'erreur était attendue (par exemple, des problèmes de saisie utilisateur) ou inattendue (par exemple, des bugs).
• erreurs : une liste facultative pour inclure des détails plus spécifiques sur l'erreur (utile pour les erreurs de validation).

Un middleware simple de gestion des erreurs

Maintenant que nous avons notre classe d'erreur personnalisée, nous avons besoin d'un moyen de gérer ces erreurs dans notre application. Entrez le middleware :

export const errorHandler = (err, req, res, next) => {
    if (err instanceof AppError) {
        // Handle operational errors
        res.status(err.httpCode).json({
            success: false,
            error: err.name,
            message: err.message,
            errors: err.errors || [],
        });
    } else {
        // Handle unexpected errors
        console.error('Unexpected Error:', err.stack); // Log the stack trace for debugging
        res.status(500).json({
            success: false,
            error: 'InternalServerError',
            message: 'Something went wrong. Please try again later.',
        });
    }
};

Qu'est-ce que ça fait ?
Vérifie le type d'erreur :
Si l’erreur est une instance d’AppError, elle est traitée comme une erreur opérationnelle. Ce sont les erreurs que vous anticipez (par exemple, des problèmes de validation ou des ressources manquantes).
S’il ne s’agit pas d’une AppError, elle est traitée comme une erreur inattendue. Il peut s'agir de bugs dans votre code ou de quelque chose que vous n'aviez pas prévu.

Responds with the right status code and message:
    For AppError instances, it sends a structured JSON response containing the error details.
    For unexpected errors, it sends a generic 500 response to the user and logs the details for debugging.

Rassembler tout ça

Imaginez que vous ayez un itinéraire dans votre application Express dans lequel les utilisateurs soumettent un formulaire, mais que certains champs manquent. Vous pouvez utiliser votre classe AppError comme ceci :

app.post('/submit-form', (req, res, next) => {
    const { name, email } = req.body;

    if (!name || !email) {
        const errors = [];
        if (!name) errors.push({ field: 'name', message: 'Name is required.' });
        if (!email) errors.push({ field: 'email', message: 'Email is required.' });

        return next(new AppError('ValidationError', 400, 'Invalid input data.', true, errors));
    }

    res.json({ success: true, message: 'Form submitted successfully!' });
});

// Register the error-handling middleware
app.use(errorHandler);

Que se passe-t-il en cas d'erreur ?
Si le nom ou l'e-mail est manquant, l'instance AppError est transmise à la fonction suivante.
Le middleware errorHandler l'attrape et envoie une réponse JSON structurée :

{
    "success": false,
    "error": "ValidationError",
    "message": "Invalid input data.",
    "errors": [
        { "field": "name", "message": "Name is required." },
        { "field": "email", "message": "Email is required." }
    ]
}

Pourquoi utiliser ce modèle ?

• Clarté : les classes d'erreurs personnalisées rendent vos erreurs plus descriptives et plus faciles à déboguer.
• Cohérence : chaque erreur suit une structure prévisible, ce qui la rend plus facile à gérer pour les développeurs frontend.
• Séparation des préoccupations : vos gestionnaires de routes se concentrent sur la logique, tandis que le middleware gère la réponse aux erreurs.

Conclusion
La gestion des erreurs ne doit pas nécessairement être complexe ! En utilisant une classe d'erreurs et un middleware personnalisés, vous pouvez créer un système robuste et convivial pour les débutants qui garantit la fiabilité de votre application et la satisfaction de vos utilisateurs.

Que pensez-vous de cette approche ? Avez-vous des conseils ou astuces pour gérer les erreurs dans Node.js ? Faites-le moi savoir dans les commentaires ci-dessous !

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!