Vejledning til undtagelseshåndtering i Express

Introduktion

Undtagelser og fejl vil helt sikkert forekomme, mens brugere interagerer med enhver applikation, det er op til softwareingeniører at vælge et middel til at håndtere enhver fejl, der måtte opstå - bevidst eller ubevidst. Som følge heraf finder backend-udviklere, der bygger API'er med Express, at de arbejder på at sikre, at de bygger en nyttig, effektiv og brugbar API. Det vigtigste er at håndtere fejl på en sådan måde, at der opbygges et robust system, fordi dette hjælper med at reducere udviklingstiden, direkte fejl, produktivitetsproblemer og bestemmer softwareudviklingens succes eller skalerbarhed.

Skal du logge fejlmeddelelsen, undertrykke fejlen, underrette brugere om fejlen eller skrive kode for at håndtere fejl? Undrer dig ikke mere.

I denne vejledning lærer vi, hvordan man opbygger en robust fejlhåndteringskodebase til Express-applikationer, som vil hjælpe med at opdage applikationsfejl og tage optimale handlinger for at genoprette enhver applikation fra yndefuldt at fejle under kørsel.

Hvad er fejlhåndtering?

Inden for softwareudvikling er der to forskellige slags undtagelser: operationelle , programmatisk.

• Driftsfejl kan opstå under kørsel, og for at forhindre, at applikationen afsluttes brat, skal vi på en yndefuld måde håndtere disse undtagelser gennem effektive fejlhåndteringsmetoder.
• Programmatiske undtagelser kastes manuelt af en programmør, når en exceptionel tilstand opstår.

Du kan tænke på operationelle undtagelser som "uventede, men forudsete" undtagelser (såsom adgang til et indeks uden for grænserne), og programmatiske undtagelser som "forventede og forudsete" undtagelser (såsom en talformateringsundtagelse).

Undtagelseshåndtering er den procedure, der bruges til at finde og rette fejl i et program. Fejlhåndtering sender meddelelser, der inkluderer typen af ​​fejl, der skete, og stakken, hvor fejlen skete.

I Express refererer undtagelseshåndtering til, hvordan Express sætter sig selv op til at fange og behandle synkrone og asynkrone undtagelser. Det gode ved undtagelseshåndtering i Express er, at du som udvikler ikke behøver at skrive dine egne undtagelsesbehandlere; Express leveres med en standard undtagelseshåndtering. Undtagelsesbehandleren hjælper med at identificere fejl og rapportere dem til brugeren. Det giver også forskellige afhjælpende strategier og implementerer dem for at afbøde undtagelser.

Selvom disse kan virke som en masse ting, der går under motorhjelmen, bremser undtagelseshåndtering i Express ikke den overordnede proces af et program eller sætter dets udførelse på pause.

Forståelse af undtagelseshåndtering i Express

Med standardfejlbehandleren, der følger med Express, har vi i vores hænder et sæt middleware-funktioner, der hjælper med at fange fejl i rutebehandlere automatisk. Snart vil vi lave et projekt for at omsætte teori til praksis om, hvordan man returnerer korrekte fejl i en Express-app, og hvordan man ikke lækker følsomme oplysninger.

Definerer middleware-funktion i Express

De fejlbehandlende middleware-funktioner er defineret på en sådan måde, at de accepterer en Error objekt som den første inputparameter, efterfulgt af standardparametrene for enhver anden middleware-funktion: request, responseog next. Det next() funktionen springer al nuværende middleware over til den næste fejlbehandler for routeren.

Opsætning af fejlhåndtering i Express

Kør følgende kommando i din terminal for at oprette en Node and Express-app:

$ mkdir error-handling-express

Lad os initialisere et nyt Node-projekt i den nyoprettede mappe:

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

Dette skaber en package.json fil i vores mappe.

For at oprette en Express-server i vores Node-app skal vi installere express pakke, dotenv til automatisk indlæsning af miljøvariabler .env fil i process.env objekt, og nodemon til genstart af node-appen, hvis en filændring er noteret i mappen.

$ npm install express dotenv nodemon

Opret derefter en app.js fil i projektmappen, som vil fungere som indeksfil for appen.

Nu hvor vi har installeret alle de nødvendige afhængigheder til vores Express-app, skal vi konfigurere scriptet til at læse appen i package.json fil. For at opnå det skal package.json fil, således at scripts objektet er som vist nedenfor:

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

Alternativt kan du springe over at bruge nodemon, og brug node app.js i stedet.

Opsætning af en Express-server

For at konfigurere serveren skal vi først importere de forskellige pakker til app.js. Vi vil også oprette en .env fil i projektbiblioteket – for at gemme alle miljøvariabler for applikationen:

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

PORT=4000 

Vi har defineret portnummeret for appen i .env, som er indlæst og læst af dotenv, og kan tilgås senere.

Initialisering af Express Server

Nu skal vi initialisere Express-serveren og få vores app til at lytte til app-portnummeret sammen med en anmodning om en testrute – /test. Lad os opdatere app.js, under importerklæringerne:

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

Herfra lærer vi, hvordan man håndterer forskellige use cases af driftsfejl, der kan opstå, i Express.

Håndtering ikke fundet fejl i Express

Antag, at du skal hente alle brugere fra en database med brugere, kan du effektivt håndtere et potentielt fejlscenarie, hvor der ikke findes data i databasen, ved at pakke logikken ind i en try/catch blok – i håb om at fange enhver fejl, der kunne projicere i catch blok:

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

Dette resulterer i:

User not found

Nu, når denne anmodning er lavet (du kan teste ved hjælp af Postman), og der ikke findes nogen bruger i databasen, modtager klienten en fejlmeddelelse, der siger "Brugeren blev ikke fundet". Du vil også bemærke, at fejlen også er logget på konsollen.

Optimering af fejlhåndtering med Error Handler Middleware

Vi kan optimere udviklingen ved at lave en fejlbehandler-middleware, der ville komme i slutningen af ​​alle definerede ruter, så hvis der smides en fejl i en af ​​ruterne, vil Express automatisk se på den næste middleware og blive ved med at gå ned på listen indtil den når fejlbehandleren. Fejlbehandleren vil behandle fejlen og også sende et svar tilbage til klienten.

For at komme i gang skal du oprette en mappe kaldet middleware i projektmappen, og i denne mappe, opret en fil kaldet errorHandler.js som definerer fejlbehandleren:

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

I vores middleware-funktion har vi gjort Express opmærksom på, at dette ikke er en grundlæggende middleware-funktion, men en fejlbehandler, ved at tilføje error parameter før de 3 grundlæggende parametre.

Nu vil vi bruge fejlbehandleren i vores demo app.js og håndtere den indledende fejl med at hente brugere med fejlbehandlerens middleware, som vist nedenfor:

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

Vi kan optimere vores kode endnu mere, ved at skabe en abstraktion omkring try/catch logik. Vi kan opnå dette ved at oprette en ny mappe i projektmappen kaldet utils, og i den skal du oprette en fil kaldet tryCatch.js.

At abstrahere try-catch logik – vi kan definere en funktion, der accepterer en anden funktion (kendt som controller) som dens parameter og returnerer en async funktion, som vil holde en try/catch for enhver modtaget controller.

Hvis der opstår en fejl i controlleren, fanges den i catch blok og den næste funktion hedder:

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

Med try/catch abstraktion, kan vi refaktorisere vores kode for at gøre den mere kortfattet ved at springe over try-catch klausul udtrykkeligt, når du henter brugere i 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);
	})
);

Vi har med succes abstraheret try-catch-logikken, og vores kode fungerer stadig, som den gjorde før.

Håndtering af valideringsfejl i Express

Til denne demo vil vi oprette en ny rute i vores Express-app til login – for at validere et bruger-id ved log ind. Først installerer vi joi pakke, for at hjælpe med at oprette et skema, som vi kan håndhæve krav med:

$ npm i joi

Opret derefter et skema, som er en Joi.object med en userId som skal være et tal og er påkrævet – hvilket betyder, at anmodningen skal matche et objekt med et bruger-id på.

Vi kan bruge validate() metode i skemaobjektet til at validere hvert input mod skemaet:

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

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

Hvis en tom genstand føres ind i validate() metode, ville fejlen blive behandlet elegant, og fejlmeddelelsen ville blive sendt til klienten:

På konsollen får vi også adgang til en details array, som indeholder forskellige detaljer om fejlen, der kan kommunikeres til brugeren, hvis det er nødvendigt.

For specifikt at håndtere valideringsfejl på en sådan måde, at den passende fejldetalje pr. valideringsfejl videregives, kan fejlbehandler-middlewaren refaktoriseres:

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;

Med errorHandler.js nu tilpasset, når vi laver den samme anmodning med et tomt objekt sendt til validate() metode:

Vi har nu adgang til et tilpasset objekt, der returnerer beskeder på en mere læsbar/venlig måde. På denne måde er vi i stand til at sende og håndtere forskellige slags fejl baseret på typen af ​​fejl, der kommer ind.

Konklusion

I denne vejledning gennemgik vi alle aspekter af Express.js' fejlhåndtering, herunder hvordan synkron og asynkron kode håndteres som standard, hvordan du laver dine egne fejlklasser, hvordan du skriver brugerdefinerede fejlhåndterings-middleware-funktioner og leverer next som den endelige fangstbehandler

Som med enhver opgave derude, er der også best practices under udvikling, som inkluderer effektiv fejlhåndtering, og i dag har vi lært, hvordan vi kan håndtere fejl i en Express-app på en robust måde.

At håndtere fejl korrekt betyder ikke kun at reducere udviklingstiden ved let at finde fejl og fejl, men også at udvikle en robust kodebase til store applikationer. I denne guide har vi set, hvordan man opsætter middleware til håndtering af driftsfejl. Nogle andre måder at forbedre fejlhåndtering på omfatter: ikke at sende stakspor, standse processer elegant for at håndtere ufangede undtagelser, levere passende fejlmeddelelser, sende fejllogfiler og opsætte en klasse, der udvider Error klasse.

Jeg håber, at de eksempler, jeg brugte i denne tutorial, var sjove for dig. Jeg dækkede forskellige scenarier, du potentielt kan støde på, når du skriver en Express-applikation til brug i den virkelige verden om fejlhåndtering. Lad mig vide, hvis der er noget, jeg er gået glip af. Det vil gavne os og hjælpe mig med at lære mere. Hav en god dag og tak fordi du læste med.

Du kan henvise til al kildekoden, der er brugt i artiklen om Github.

Yderligere ressourcer