Beim Erstellen von Webanwendungen laufen die Dinge nicht immer wie geplant. Benutzer versuchen m?glicherweise ungültige Vorg?nge, Daten fehlen m?glicherweise oder es k?nnen unerwartete Fehler auftreten. Der ordnungsgem??e Umgang mit diesen Fehlern ist für die Erstellung einer zuverl?ssigen Anwendung und die Bereitstellung einer guten Benutzererfahrung von entscheidender Bedeutung.

In diesem Beitrag zeige ich Ihnen, wie Sie ein einfaches und effektives Fehlerbehandlungssystem in Ihrer Node.js-Anwendung implementieren. Lass uns eintauchen! ?

Die Grundlagen der Fehlerbehandlung

In JavaScript wird ein Fehler normalerweise als Instanz der Error-Klasse dargestellt. Wenn etwas schief geht, k?nnen Sie einen Fehler ausl?sen, und Ihre Anwendung kann ihn abfangen und entsprechend reagieren. In gr??eren Anwendungen kann es jedoch schwierig werden, Fehler nur mit der Basisklasse ?Error“ zu verwalten.

Hier kommen benutzerdefinierte Fehlerklassen zum Einsatz!
Erstellen einer benutzerdefinierten Fehlerklasse

Hier ist eine Klasse namens AppError, mit der wir strukturierte und aussagekr?ftige Fehler definieren k?nnen:

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
    }
}

Wie funktioniert es?

• Name: Beschreibt die Art des Fehlers, z. B. ValidationError oder NotFoundError.
• httpCode: Legt einen geeigneten HTTP-Statuscode fest, z. B. 400 für fehlerhafte Anfragen oder 500 für Serverfehler.
• Beschreibung: Bietet eine benutzerfreundliche Meldung, die den Fehler beschreibt.
• isOperational: Ein boolesches Flag, das angibt, ob der Fehler erwartet (z. B. Benutzereingabeprobleme) oder unerwartet (z. B. Fehler) war.
• Fehler: Eine optionale Liste, die genauere Details zum Fehler enth?lt (nützlich bei Validierungsfehlern).

Eine einfache Fehlerbehandlungs-Middleware

Da wir nun unsere benutzerdefinierte Fehlerklasse haben, ben?tigen wir eine M?glichkeit, diese Fehler in unserer App zu behandeln. Geben Sie Middleware ein:

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.',
        });
    }
};

Was bewirkt das?
überprüft den Fehlertyp:
Wenn es sich bei dem Fehler um eine Instanz von AppError handelt, wird er als Betriebsfehler behandelt. Dies sind die Fehler, die Sie erwarten (z. B. Validierungsprobleme oder fehlende Ressourcen).
Wenn es sich nicht um einen AppError handelt, wird er als unerwarteter Fehler behandelt. Dies k?nnen Fehler in Ihrem Code sein oder etwas, das Sie nicht geplant haben.

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.

Alles zusammenfügen

Stellen Sie sich vor, Sie haben in Ihrer Express-App eine Route, bei der Benutzer ein Formular einreichen, aber einige Felder fehlen. Sie k?nnen Ihre AppError-Klasse wie folgt verwenden:

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);

Was passiert, wenn ein Fehler vorliegt?
Wenn der Name oder die E-Mail-Adresse fehlen, wird die AppError-Instanz an die n?chste Funktion übergeben.
Die errorHandler-Middleware f?ngt es ab und sendet eine strukturierte JSON-Antwort:

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

Warum dieses Muster verwenden?

• Klarheit: Benutzerdefinierte Fehlerklassen machen Ihre Fehler aussagekr?ftiger und einfacher zu debuggen.
• Konsistenz: Jeder Fehler folgt einer vorhersehbaren Struktur, was den Umgang für Frontend-Entwickler erleichtert.
• Trennung von Belangen: Ihre Routenhandler konzentrieren sich auf die Logik, w?hrend die Middleware die Fehlerantwort übernimmt.

Fazit
Fehlerbehandlung muss nicht komplex sein! Durch die Verwendung einer benutzerdefinierten Fehlerklasse und Middleware k?nnen Sie ein robustes und einsteigerfreundliches System aufbauen, das dafür sorgt, dass Ihre App zuverl?ssig und Ihre Benutzer zufrieden sind.

Was halten Sie von diesem Ansatz? Haben Sie Tipps oder Tricks zum Umgang mit Fehlern in Node.js? Lass es mich unten in den Kommentaren wissen!

Das obige ist der detaillierte Inhalt vonAufbau eines einfachen und effektiven Fehlerbehandlungssystems in Node.js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!