Leitfaden zur Ausnahmebehandlung in Express

Einleitung

Ausnahmen und Fehler treten zwangsläufig auf, während Benutzer mit einer Anwendung interagieren. Es liegt an den Softwareentwicklern, ein Mittel zu wählen, um auftretende Fehler zu behandeln – wissentlich oder unwissentlich. Infolgedessen arbeiten Backend-Entwickler, die APIs mit Express erstellen, daran, sicherzustellen, dass sie eine nützliche, effiziente und verwendbare API erstellen. Am wichtigsten ist es, Fehler so zu behandeln, dass ein robustes System aufgebaut wird, da dies dazu beiträgt, die Entwicklungszeit, regelrechte Fehler und Produktivitätsprobleme zu reduzieren, und den Erfolg oder die Skalierbarkeit der Softwareentwicklung bestimmt.

Müssen Sie die Fehlermeldung protokollieren, den Fehler unterdrücken, Benutzer über den Fehler benachrichtigen oder Code zur Fehlerbehandlung schreiben? Wundere dich nicht mehr.

In diesem Leitfaden erfahren Sie, wie Sie eine robuste Codebasis zur Fehlerbehandlung für Express-Anwendungen erstellen, die dazu dient, Anwendungsfehler zu erkennen und optimale Maßnahmen zu ergreifen, um eine Anwendung nach einem ordnungsgemäßen Ausfall während der Laufzeit wiederherzustellen.

Was ist Fehlerbehandlung?

In der Softwareentwicklung gibt es zwei verschiedene Arten von Ausnahmen: Betriebs- und Programmatic.

• Während der Laufzeit können Betriebsausfälle auftreten, und um zu verhindern, dass die Anwendung abrupt beendet wird, müssen wir diese Ausnahmen durch effiziente Fehlerbehandlungsmethoden ordnungsgemäß behandeln.
• Programmatische Ausnahmen werden manuell von einem Programmierer ausgelöst, wenn ein Ausnahmezustand auftritt.

Sie können sich Betriebsausnahmen als „unerwartete, aber vorhergesehene“ Ausnahmen (z. B. Zugriff auf einen Index außerhalb der Grenzen) und programmatische Ausnahmen als „erwartete und vorhergesehene“ Ausnahmen (z. B. eine Ausnahme bei der Zahlenformatierung) vorstellen.

Die Ausnahmebehandlung ist das Verfahren, mit dem Fehler in einem Programm gefunden und behoben werden. Die Fehlerbehandlung sendet Nachrichten, die die Art des aufgetretenen Fehlers und den Stapel enthalten, in dem der Fehler aufgetreten ist.

In Express bezieht sich die Ausnahmebehandlung darauf, wie Express sich selbst einrichtet, um synchrone und asynchrone Ausnahmen abzufangen und zu verarbeiten. Das Gute an der Ausnahmebehandlung in Express ist, dass Sie als Entwickler keine eigenen Ausnahmebehandlungsroutinen schreiben müssen; Express wird mit einem standardmäßigen Ausnahmehandler geliefert. Der Ausnahmehandler hilft bei der Identifizierung von Fehlern und deren Meldung an den Benutzer. Es bietet auch verschiedene Abhilfestrategien und implementiert sie, um Ausnahmen zu mildern.

Während dies wie eine Menge Dinge erscheinen mag, die unter die Haube gehen, verlangsamt die Ausnahmebehandlung in Express nicht den Gesamtprozess eines Programms oder hält seine Ausführung an.

Grundlegendes zur Ausnahmebehandlung in Express

Mit dem Standard-Error-Handler, der mit Express geliefert wird, haben wir eine Reihe von Middleware-Funktionen in unseren Händen, die dabei helfen, Fehler in Route-Handlern automatisch abzufangen. Bald werden wir ein Projekt erstellen, um die Theorie in die Praxis umzusetzen, wie man korrekte Fehler in einer Express-App zurückgibt und wie man vertrauliche Informationen nicht preisgibt.

Definieren der Middleware-Funktion in Express

Die Fehlerbehandlungs-Middleware-Funktionen sind so definiert, dass sie eine akzeptieren Error Objekt als erster Eingabeparameter, gefolgt von den Standardparametern jeder anderen Middleware-Funktion: request, response und nextdem „Vermischten Geschmack“. Seine next() -Funktion überspringt die gesamte aktuelle Middleware zum nächsten Fehlerbehandler für den Router.

Einrichten der Fehlerbehandlung in Express

Führen Sie den folgenden Befehl in Ihrem Terminal aus, um eine Node- und Express-App zu erstellen:

$ mkdir error-handling-express

Lassen Sie uns im neu erstellten Ordner ein neues Node-Projekt initialisieren:

$ cd error-handling-express && npm init -y

Dies schafft ein package.json Datei in unserem Ordner.

Um einen Express-Server in unserer Node-App zu erstellen, müssen wir die express Paket, dotenv zum automatischen Laden von Umgebungsvariablen in .env Datei in process.env Objekt, und nodemon zum Neustart der Node-App, wenn eine Dateiänderung im Verzeichnis festgestellt wird.

$ npm install express dotenv nodemon

Erstellen Sie als Nächstes eine app.js Datei im Projektordner, die als Indexdatei für die App dient.

Nachdem wir alle erforderlichen Abhängigkeiten für unsere Express-App installiert haben, müssen wir das Skript zum Lesen der App in der package.json Datei. Um das zu erreichen, die package.json Datei, damit die scripts Objekt ist wie unten gezeigt:

"scripts": {
    "start": "nodemon app.js"
},

Alternativ können Sie die Verwendung überspringen nodemonund verwenden node app.js stattdessen.

Einrichten eines Express-Servers

Um den Server einzurichten, müssen wir zunächst die verschiedenen Pakete in importieren app.js. Wir erstellen auch eine .env Datei im Projektverzeichnis – um alle Umgebungsvariablen für die Anwendung zu speichern:

const express = require('express')
require('dotenv').config

PORT=4000 

Wir haben die Portnummer für die App in definiert .env, die geladen und gelesen wird dotenv, und kann später aufgerufen werden.

Initialisieren des Express-Servers

Jetzt müssen wir den Express-Server initialisieren und unsere App dazu bringen, auf die App-Portnummer zu hören, zusammen mit einer Anfrage an eine Testroute – /test. Lassen Sie uns aktualisieren app.js, unter den import-Anweisungen:

const app = express();
const port = process.env.PORT || 4000;

app.get("/test", async (req, res) => {
    return res.status(200).json({ success: true });
});

app.listen(port, () => {
    console.log(`Server is running at port ${port}`);
});

Von hier an lernen wir, wie mit verschiedenen Anwendungsfällen von Betriebsfehlern umgegangen wird, die in Express auftreten können.

Umgang mit nicht gefundenen Fehlern in Express

Angenommen, Sie müssen alle Benutzer aus einer Benutzerdatenbank abrufen, können Sie ein potenzielles Fehlerszenario effizient handhaben, bei dem keine Daten in der Datenbank vorhanden sind, indem Sie die Logik in a try/catch Block – in der Hoffnung, jeden Fehler abzufangen, der in den projizieren könnte catch Block:

const getUser = () => undefined;

app.get("/get-user", async (req, res) => {
	try {
		const user = getUser();
		if (!user) {
			throw new Error('User not found');
		}
	} catch (error) {
	    
		console.log(error); 
		
		res.status(400).send(error.message) 
	}
	return res.status(200).json({
		success: true
	});
});

Das führt zu:

User not found

Wenn nun diese Anfrage gestellt wird (Sie können dies mit Postman testen) und kein Benutzer in der Datenbank vorhanden ist, erhält der Client eine Fehlermeldung mit der Aufschrift „Benutzer nicht gefunden“. Außerdem werden Sie feststellen, dass der Fehler auch in der Konsole protokolliert wird.

Optimieren der Fehlerbehandlung mit Error Handler Middleware

Wir können die Entwicklung optimieren, indem wir eine Fehlerbehandlungs-Middleware erstellen, die am Ende aller definierten Routen kommt, sodass Express automatisch einen Blick auf die nächste Middleware wirft und die Liste weiter nach unten geht, wenn ein Fehler in eine der Routen geworfen wird bis es den Fehlerbehandler erreicht. Der Fehlerbehandler verarbeitet den Fehler und sendet auch eine Antwort an den Client zurück.

Erstellen Sie zunächst einen Ordner mit dem Namen middleware im Projektverzeichnis und erstellen Sie in diesem Ordner eine Datei mit dem Namen errorHandler.js was den Fehlerhandler definiert:

const errorHandler = (error, req, res, next) => {
    
    console.log(error); 
    
    res.status(400).send(error.message); 
}
module.exports = errorHandler;

In unserer Middleware-Funktion haben wir Express darauf aufmerksam gemacht, dass es sich nicht um eine grundlegende Middleware-Funktion, sondern um einen Fehlerbehandler handelt, indem wir die hinzugefügt haben error Parameter vor den 3 Grundparametern.

Jetzt verwenden wir den Fehlerhandler in unserer Demo app.js und behandeln Sie den anfänglichen Fehler beim Abrufen von Benutzern mit der Fehlerbehandlungs-Middleware, wie unten gezeigt:

const getUser = () => undefined;

app.get("/get-user", async (req, res, next) => {
	try {
		const user = getUser();
		if (!user) {
			throw new Error("User not found");
		}
	} catch (error) {
		return next(error);
	}
});

app.use(errorHandler);

Wir können unseren Code noch weiter optimieren, indem wir eine Abstraktion um die erstellen try/catch Logik. Wir können dies erreichen, indem wir im Projektverzeichnis einen neuen Ordner mit dem Namen erstellen utils, und erstellen Sie darin eine Datei namens tryCatch.js.

Das zu abstrahieren try-catch Logik – wir können eine Funktion definieren, die eine andere Funktion akzeptiert (bekannt als die Controller) als seinen Parameter und gibt an zurück async Funktion, die a halten wird try/catch für jeden empfangenen Controller.

Tritt ein Fehler in der Steuerung auf, wird dieser in der abgefangen catch Block und die nächste Funktion wird aufgerufen:

const tryCatch = (controller) => async (req, res, next) => {
	try {
		await controller(req, res);
	} catch (error) {
		return next(error);
	}
};
module.exports = tryCatch;

Mit der try/catch Abstraktion können wir unseren Code umgestalten, um ihn prägnanter zu machen, indem wir das überspringen try-catch -Klausel ausdrücklich beim Abrufen von Benutzern in der app.js:

const getUser = () => undefined;

app.get(
	"/get-user",
	tryCatch(async (req, res) => {
		const user = getUser();
		if (!user) {
			throw new Error("User not found");
		}
		res.status(400).send(error.message);
	})
);

Wir haben die Try-Catch-Logik erfolgreich abstrahiert und unser Code funktioniert immer noch wie zuvor.

Umgang mit Validierungsfehlern in Express

Für diese Demo erstellen wir eine neue Route in unserer Express-App für die Anmeldung – um eine Benutzer-ID beim Anmelden zu validieren. Zuerst installieren wir die joi Paket, um beim Erstellen eines Schemas zu helfen, mit dem wir Anforderungen durchsetzen können:

$ npm i joi

Erstellen Sie als Nächstes ein Schema, bei dem es sich um a handelt Joi.object mit userId Dies muss eine Zahl sein und ist erforderlich – was bedeutet, dass die Anfrage mit einem Objekt mit einer darauf befindlichen Benutzer-ID übereinstimmen muss.

Wir können das benutzen validate() -Methode im Schemaobjekt, um jede Eingabe anhand des Schemas zu validieren:

const schema = Joi.object({
	userId: Joi.number().required(),
});

app.post(
	"/login",
	tryCatch(async (req, res) => {
		const {error, value} = schema.validate({});
		if (error) throw error;
	})
);

Wenn ein leeres Objekt in die übergeben wird validate() -Methode würde der Fehler ordnungsgemäß behandelt und die Fehlermeldung an den Client gesendet:

Auf der Konsole erhalten wir auch Zugriff auf a details Array, das verschiedene Details über den Fehler enthält, die dem Benutzer bei Bedarf mitgeteilt werden könnten.

Um Validierungsfehler speziell so zu behandeln, dass das entsprechende Fehlerdetail pro Validierungsfehler übergeben wird, kann die Error-Handler-Middleware umgestaltet werden:

const errorHandler = (error, req, res, next) => {
	console.log(error); 

	if (error.name === "ValidationError") {
		return res.status(400).send({
			type: "ValidationError",
			details: error.details,
		});
	}

	res.status(400).send(error.message); 
};

module.exports = errorHandler;

Mit der errorHandler.js jetzt angepasst, wenn wir die gleiche Anfrage mit einem leeren Objekt stellen, das an die übergeben wird validate() Verfahren:

Wir haben jetzt Zugriff auf ein benutzerdefiniertes Objekt, das Nachrichten lesbarer/freundlicher zurückgibt. Auf diese Weise sind wir in der Lage, je nach Art des eingehenden Fehlers verschiedene Arten von Fehlern zu senden und zu behandeln.

Zusammenfassung

In diesem Leitfaden haben wir jeden Aspekt der Fehlerbehandlung von Express.js besprochen, einschließlich der standardmäßigen Behandlung von synchronem und asynchronem Code, der Erstellung eigener Fehlerklassen, der Erstellung benutzerdefinierter Middleware-Funktionen zur Fehlerbehandlung und der Bereitstellung next als letzter Catch-Handler

Wie bei jeder Aufgabe da draußen gibt es auch während der Entwicklung Best Practices, die eine effektive Fehlerbehandlung beinhalten, und heute haben wir gelernt, wie wir Fehler in einer Express-App robust behandeln können.

Der richtige Umgang mit Fehlern bedeutet nicht nur, die Entwicklungszeit zu verkürzen, indem Bugs und Fehler leicht gefunden werden, sondern auch eine robuste Codebasis für umfangreiche Anwendungen zu entwickeln. In diesem Leitfaden haben wir gesehen, wie man Middleware zur Behandlung von Betriebsfehlern einrichtet. Einige andere Möglichkeiten zur Verbesserung der Fehlerbehandlung sind: keine Stack-Traces senden, Prozesse ordnungsgemäß stoppen, um nicht abgefangene Ausnahmen zu behandeln, geeignete Fehlermeldungen bereitstellen, Fehlerprotokolle senden und eine Klasse einrichten, die die erweitert Error Klasse.

Ich hoffe, die Beispiele, die ich in diesem Tutorial verwendet habe, haben Ihnen gefallen. Ich habe verschiedene Szenarien behandelt, auf die Sie möglicherweise stoßen könnten, wenn Sie eine Express-Anwendung zur Verwendung in der realen Welt zur Fehlerverwaltung schreiben. Bitte lassen Sie mich wissen, wenn ich etwas übersehen habe. Es wird uns zugute kommen und mir auch helfen, mehr zu lernen. Ich wünsche Ihnen einen schönen Tag und danke fürs Lesen.

Sie können auf den gesamten im Artikel verwendeten Quellcode verweisen Github.

Weitere Informationen