Veiledning til unntakshåndtering i Express

Introduksjon

Unntak og feil vil nødvendigvis oppstå mens brukere samhandler med en applikasjon, det er opp til programvareingeniører å velge en måte å håndtere eventuelle feil som kan oppstå – bevisst eller ubevisst. Som et resultat finner backend-utviklere som bygger APIer med Express at de jobber for å sikre at de bygger en nyttig, effektiv og brukbar API. Det som er viktigst er å håndtere feil på en slik måte at man bygger et robust system fordi dette bidrar til å redusere utviklingstiden, direkte feil, produktivitetsproblemer og bestemmer suksessen eller skalerbarheten til programvareutvikling.

Trenger du å logge feilmeldingen, undertrykke feilen, varsle brukere om feilen eller skrive kode for å håndtere feil? Lurer ikke lenger.

I denne veiledningen vil vi lære hvordan du bygger en robust feilhåndteringskodebase for Express-applikasjoner, som vil hjelpe til med å oppdage applikasjonsfeil og iverksette optimale handlinger for å gjenopprette enhver applikasjon fra å mislykkes under kjøring.

Hva er feilhåndtering?

I programvareutvikling er det to forskjellige typer unntak: operasjonell og programma.

• Driftsfeil kan oppstå under kjøring, og for å forhindre at applikasjonen avsluttes brått, må vi behandle disse unntakene på en elegant måte gjennom effektive feilhåndteringsmetoder.
• Programmatiske unntak blir kastet manuelt av en programmerer når en eksepsjonell tilstand oppstår.

Du kan tenke på operasjonelle unntak som "uventede, men forutsette" unntak (for eksempel tilgang til en indeks utenfor grensene), og programmatiske unntak som "forventede og forutsette" unntak (for eksempel et tallformateringsunntak).

Unntakshåndtering er prosedyren som brukes til å finne og fikse feil i et program. Feilhåndtering sender meldinger som inkluderer typen feil som skjedde og stabelen der feilen skjedde.

I Express refererer unntakshåndtering til hvordan Express setter seg opp til å fange og behandle synkrone og asynkrone unntak. Det som er bra med unntakshåndtering i Express er at du som utvikler ikke trenger å skrive dine egne unntaksbehandlere; Express kommer med en standard unntaksbehandler. Unntaksbehandleren hjelper til med å identifisere feil og rapportere dem til brukeren. Den gir også ulike utbedringsstrategier og implementerer dem for å redusere unntak.

Selv om disse kan virke som mange ting som går under panseret, bremser ikke unntakshåndteringen i Express den generelle prosessen til et program eller pauser utførelsen.

Forstå unntakshåndtering i Express

Med standard feilbehandler som følger med Express, har vi i våre hender et sett med mellomvarefunksjoner som bidrar til å fange opp feil i rutebehandlere automatisk. Snart vil vi lage et prosjekt for å sette teori ut i praksis om hvordan man returnerer riktige feil i en Express-app og hvordan man ikke skal lekke sensitiv informasjon.

Definere mellomvarefunksjon i Express

Mellomvarefunksjonene for feilhåndtering er definert på en slik måte at de aksepterer en Error objekt som den første inngangsparameteren, etterfulgt av standardparameterne for enhver annen mellomvarefunksjon: request, responseog next. De next() funksjonen hopper over all gjeldende mellomvare til neste feilbehandler for ruteren.

Sette opp feilhåndtering i Express

Kjør følgende kommando i terminalen din for å lage en Node and Express-app:

$ mkdir error-handling-express

I den nyopprettede mappen, la oss initialisere et nytt nodeprosjekt:

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

Dette skaper en package.json fil i mappen vår.

For å opprette en Express-server i Node-appen vår, må vi installere express pakke, dotenv for automatisk innlasting av miljøvariabler .env filen inn process.env objekt, og nodemon for å starte nodeappen på nytt hvis en filendring er notert i katalogen.

$ npm install express dotenv nodemon

Deretter oppretter du en app.js fil i prosjektmappen som vil fungere som indeksfilen for appen.

Nå som vi har installert alle nødvendige avhengigheter for Express-appen vår, må vi sette opp skriptet for å lese appen i package.json fil. For å oppnå det, må package.json fil, slik at scripts objektet er som vist nedenfor:

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

Alternativt kan du hoppe over å bruke nodemon, og bruk node app.js i stedet.

Sette opp en Express-server

For å sette opp serveren, må vi først importere de forskjellige pakkene til app.js. Vi vil også lage en .env fil i prosjektkatalogen – for å lagre alle miljøvariabler for applikasjonen:

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

PORT=4000 

Vi har definert portnummeret for appen i .env, som lastes inn og leses av dotenv, og kan nås senere.

Initialisere Express Server

Nå må vi initialisere Express-serveren og få appen vår til å lytte til appportnummeret, sammen med en forespørsel om en testrute – /test. La oss oppdatere app.js, under importerklæringene:

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 vil vi lære å håndtere ulike brukstilfeller av driftsfeil som kan oppstå, i Express.

Håndtering ikke funnet feil i Express

Anta at du trenger å hente alle brukere fra en database med brukere, kan du effektivt håndtere et potensielt feilscenario der det ikke finnes data i databasen, ved å pakke inn logikken i en try/catch blokk – i håp om å fange opp eventuelle feil som kan projisere i catch blokkere:

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

Nå, når denne forespørselen er gjort (du kan teste med Postman) og ingen bruker eksisterer i databasen, mottar klienten en feilmelding som sier "Bruker ikke funnet". Du vil også legge merke til at feilen er logget på konsollen også.

Optimalisering av feilhåndtering med mellomvare for feilbehandler

Vi kan optimere utviklingen ved å lage en feilbehandler-mellomvare som vil komme på slutten av alle definerte ruter, slik at hvis en feil blir kastet i en av rutene, vil Express automatisk se på neste mellomvare og fortsette nedover listen til den når feilbehandleren. Feilbehandleren vil behandle feilen og også sende tilbake et svar til klienten.

For å komme i gang, lag en mappe som heter middleware i prosjektkatalogen, og i denne mappen, opprett en fil som heter errorHandler.js som definerer feilbehandleren:

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

I mellomvarefunksjonen vår har vi gjort Express oppmerksom på at dette ikke er en grunnleggende mellomvarefunksjon, men en feilbehandler, ved å legge til error parameter før de 3 grunnleggende parameterne.

Nå skal vi bruke feilbehandleren i demoen vår app.js og håndtere den første feilen med å hente brukere med mellomvaren for feilbehandler, 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 optimalisere koden vår enda mer ved å lage en abtraksjon rundt try/catch logikk. Vi kan oppnå dette ved å opprette en ny mappe i prosjektkatalogen kalt utils, og i den oppretter du en fil som heter tryCatch.js.

Å abstrahere try-catch logikk – vi kan definere en funksjon som godtar en annen funksjon (kjent som controller) som parameter, og returnerer en async funksjon som vil inneholde en try/catch for alle mottatte kontroller.

Hvis det oppstår en feil i kontrolleren, fanges den opp i catch blokk og neste funksjon kalles:

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

Med try/catch abstraksjon, kan vi refaktorisere koden vår for å gjøre den mer kortfattet ved å hoppe over try-catch klausul eksplisitt når du henter brukere 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 lykkes med å abstrahere try-catch-logikken og koden vår fungerer fortsatt som den gjorde før.

Håndtering av valideringsfeil i Express

For denne demoen vil vi opprette en ny rute i Express-appen vår for pålogging – for å validere en bruker-ID ved pålogging. Først vil vi installere joi pakke, for å hjelpe med å lage et skjema som vi kan håndheve krav med:

$ npm i joi

Deretter lager du et skjema som er en Joi.object med en userId som må være et tall og er påkrevd – noe som betyr at forespørselen må samsvare med et objekt med en bruker-ID på.

Vi kan bruke validate() metode i skjemaobjektet for å validere alle inndata mot skjemaet:

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 gjenstand sendes inn i validate() metoden vil feilen bli håndtert på en elegant måte, og feilmeldingen vil bli sendt til klienten:

På konsollen får vi også tilgang til en details array som inkluderer ulike detaljer om feilen som kan kommuniseres til brukeren om nødvendig.

For å spesifikt håndtere valideringsfeil på en slik måte at den passer feildetaljene per valideringsfeil, kan mellomvaren for feilbehandleren refaktoreres:

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 nå tilpasset, når vi gjør den samme forespørselen med et tomt objekt sendt til validate() metode:

Vi har nå tilgang til et tilpasset objekt som returnerer meldinger på en mer lesbar/vennlig måte. På denne måten er vi i stand til å sende og håndtere ulike typer feil basert på hva slags feil som kommer inn.

konklusjonen

I denne veiledningen gikk vi over alle aspekter av Express.js' feilhåndtering, inkludert hvordan synkron og asynkron kode håndteres som standard, hvordan du lager dine egne feilklasser, hvordan du skriver tilpassede feilhåndteringsfunksjoner og gir next som siste fangstbehandler

Som med alle oppgaver der ute, er det også beste praksis under utvikling som inkluderer effektiv feilhåndtering, og i dag har vi lært hvordan vi kan håndtere feil i en Express-app på en robust måte.

Å håndtere feil på riktig måte betyr ikke bare å redusere utviklingstiden ved å finne feil og feil enkelt, men også å utvikle en robust kodebase for store applikasjoner. I denne veiledningen har vi sett hvordan du setter opp mellomvare for håndtering av driftsfeil. Noen andre måter å forbedre feilhåndtering på inkluderer: ikke sende stabelspor, stoppe prosesser på en elegant måte for å håndtere uoppdagede unntak, gi passende feilmeldinger, sende feillogger og sette opp en klasse som utvider Error klasse.

Jeg håper eksemplene jeg brukte i denne opplæringen var morsomme for deg. Jeg dekket ulike scenarier du potensielt kan støte på når du skriver en Express-applikasjon for bruk i den virkelige verden om feilhåndtering. Gi meg beskjed hvis det er noe jeg har gått glipp av. Det vil være til nytte for oss og hjelpe meg å lære mer også. Ha en fin dag og takk for at du leser.

Du kan referere til all kildekoden som er brukt i artikkelen om Github.

Tilleggsressurser