Oppdag de ulike typene feil du kan håndtere, og hvordan du kan bruke Express.js til å håndtere dem.

Viktige takeaways

  • Feil i Express.js-applikasjoner kan kategoriseres i syntaks- og kjøretidsfeil, inndatavalidering og brukerfeil, database- og nettverksrelaterte feil, og tredjeparts API- og tjenestefeil.
  • Å fange og logge feil til konsollen er en enkel måte å håndtere feil under utviklings- og feilsøkingsfasene i Express.js. Feilhåndteringspakker som express-error-handler gir klar-til-bruk funksjonalitet for å administrere og svare på feil.
  • Håndtering av synkrone og asynkrone feil ved å bruke try-catch-blokker er en effektiv teknikk i Express.js. For asynkrone operasjoner kan integrering av asynkron- og vent-nøkkelord i try-catch-blokker forbedre feilhåndteringen. Å lage tilpasset feilhåndteringsmiddelvare muliggjør en sentralisert og skreddersydd tilnærming til feilhåndtering.

I et ideelt scenario bygger du API-ene og backend-tjenestene dine, distribuerer dem til produksjon, og lener deg tilbake og slapper av mens andre bruker dem. Dessverre, i den virkelige verden, vil programmene du skriver nesten helt sikkert inneholde feil og feil.

Av denne grunn, når du utvikler Express.js API-er og backend-tjenester, er det viktig å ta hensyn til hvordan forskjellige feil kan oppstå og hvordan du håndterer dem effektivt.

Ved å forutse slike scenarier kan du sikre at appene dine ikke bare håndterer feil effektivt, men også gir brukerne en sømløs opplevelse.

Vanlige typer feil i Express.js-applikasjoner

Når du utvikler Express.js-applikasjoner, vil du støte på ulike typer feil, inkludert:

  1. Syntaks og kjøretidsfeil: Syntaksfeil oppstår når det er feil i kodens syntaks, noe som betyr at applikasjonen ikke kan kjøre. Kjøretidsfeil, derimot, oppstår når programmet kjører, vanligvis på grunn av uventede forhold eller feil data.
  2. Inndatavalidering og brukerfeil: Disse feilene oppstår når brukere oppgir utilstrekkelige eller ugyldige data under interaksjoner med applikasjonen. Disse feilene kan manifestere seg i ulike former, for eksempel manglende obligatoriske felt, feil dataformater eller verdier som ikke oppfyller spesifikke kriterier.
  3. Database- og nettverksrelaterte feil: Database- og nettverksrelaterte feil kan oppstå når det er et problem med å koble til en database eller når kommunikasjon med eksterne applikasjoner over nettverket mislykkes. Disse feilene kan være spesielt plagsomme hvis applikasjonen din er avhengig av at nettverket fungerer.
  4. Tredjeparts API og tjenestefeil: Det kan også oppstå feil når du samhandler med eksterne APIer eller tjenester. Ved forespørsler til eksterne systemer kan det oppstå ulike problemer. For eksempel kan API-en oppleve nedetid, returnere svar med feil på grunn av ugyldige parametere, eller returnere uventede dataformater.

Det finnes ulike teknikker du kan bruke for å effektivt håndtere feil i Express.js REST APIer og backend-tjenester.

1. Fange og logge feil til konsollen

En enkel måte å håndtere feil på er å fange dem og logge detaljene til konsollen. Denne tilnærmingen hjelper deg med å identifisere feil under utviklings- og feilsøkingsfasene.

Ved bruk av console.error(), kan du få innsikt i arten og plasseringen av feil i applikasjonen din. Her er et kodeeksempel:

app.get('/example', (req, res) => {
try {
// Code that may cause an error
const result = someFunction();
 res.json(result);
 } catch (error) {
console.error('Error occurred:', error);
 res.status(500).json({ message: 'An error occurred.' });
 }
});

2. Bruk av feilhåndteringspakker

Express.js tilbyr flere mellomvarepakker for feilhåndtering for å effektivisere feilhåndtering. En slik pakke er express-error-handler— disse pakkene gjør det enklere å håndtere og svare på feil ved å tilby funksjonalitet som er klar til bruk, for eksempel tilpassede feilmeldinger og feilloggingsfunksjoner.

For å bruke denne pakken må du installere den i prosjektet ditt:

npm install express-error-handler

Når den er installert, kan du bruke funksjonene til å forbedre applikasjonens evne til å håndtere feil.

const errorHandler = require('express-error-handler');
// Register the error-handling middleware
app.use(errorHandler({
static: {
'404': 'path/to/404.html'
 }
}));

For eksempel, i eksemplet ovenfor, anta at en bruker ber om en rute som ikke eksisterer. Behandlerfunksjonen vil utløse og omdirigere brukeren til en tilpasset 404-feilside, 404.html. Dette sikrer at Express.js-applikasjonen effektivt håndterer en side-ikke-funnet-feil.

I hovedsak gir disse pakkene en mer brukervennlig tilnærming til å håndtere feil som kan oppstå.

3. Håndtering av synkrone og asynkrone feil ved å bruke Try-Catch-blokker

Håndtering synkron og asynkron programmering feil ved bruk av try-catch-blokker er en effektiv teknikk i Express.js. For synkron kode kan du håndtere feil ved å pakke den potensielt feilutsatte delen inn i en prøvefangst-blokk.

Her er et kodeeksempel som viser prøvefangstblokker i bruk:

app.get('/data', (req, res) => {
try {
// code that may cause an error
const result = someFunction();
 res.json(result);
 } catch (error) {
console.error('Error occurred:', error);
 res.status(500).json({ message: 'An error occurred.' });
 }
});

Men når du arbeider med asynkrone operasjoner som databasespørringer eller ved hjelp av Axiosfor å konsumere APIer, kan det hende at try-catch-blokker alene ikke er nok. I slike tilfeller kan du nå integrere asynkron og vent nøkkelord i blokkene for å håndtere feil mer effektivt.

Her er noen eksempelkode:

app.get('/data', async (req, res) => {
try {
const data = await fetchDataFromDatabase();
 res.json(data);
 } catch (error) {
console.error('Async Error:', error);
 res.status(500).json({ message: 'Error occurred fetching data.' });
 }
});

4. Opprette egendefinert mellomvare for feilhåndtering

Tilpasset feilhåndteringsmiddelvare lar deg definere hvordan programmet ditt håndterer feil og deres tilsvarende svar, i henhold til applikasjonens krav.

Ved å lage feilhåndteringsmiddelvarefunksjoner kan du sentralisere og tilpasse feilhåndtering, og sikre en mer organisert og skreddersydd tilnærming til håndtering av feil på tvers av hele applikasjonen.

Her er et eksempel på en egendefinert mellomvarefunksjonskode:

// Custom middleware for handling not found errors
const notFoundHandler = (req, res, next) => {
const resource = req.params.resource;

if (resource 'users') {
return res.status(404).json({ message: 'User not found.' });
 } elseif (resource 'products') {
return res.status(404).json({ message: 'Product not found.' });
 } else {
return res.status(404).json({ message: 'Requested resource not found.' });
 }
};
app.use('/api/:resource', notFoundHandler);

I dette eksemplet er notFoundHandler funksjonen sjekker ressurs parameter i forespørsels-URL. Avhengig av verdien som er oppgitt, svarer behandlerfunksjonen med tilpassede feilmeldinger for ulike typer ressurser, for eksempel brukere og produkter.

For enhver annen ressurs som ikke eksplisitt håndteres, gir den en generisk feilmelding. Alternativt, innenfor denne mellomvaren, kan du også velge å rute brukere til egendefinerte feilsider som hjelper dem med hvordan de skal løse problemene de har møtt.

Ved å bruke denne egendefinerte mellomvaren for feilhåndtering kan du skreddersy feilhåndtering og svar til ulike situasjoner, noe som gjør feilhåndteringen mer spesifikk og informativ.

I et produksjonsmiljø er det viktig å implementere feillogging og overvåking for å holde styr på applikasjonsfeil. Noen effektive verktøy du kan bruke inkluderer Winston og Morgan, blant andre. Disse verktøyene logger feil til en fil, en sentralisert server eller en overvåkingsplattform, slik at du raskt kan identifisere og løse problemer.

Her er et eksempel på hvordan du kan bruke Winston i en Express.js-applikasjon for feillogging:

const winston = require('winston');
const expressWinston = require('express-winston');
app.use(expressWinston.errorLogger({
// Error logging middleware using Winston
}));

Feilhåndtering i Backend-applikasjoner

Implementering av effektive feilhåndteringsteknikker og feilsikre prosedyrer er avgjørende for å bygge robuste backend-applikasjoner.

I Express.js-applikasjoner er det viktig å forutse, planlegge og implementere effektive feilhåndteringsteknikker som lar deg raskt identifisere, administrere og svare på feil. Dette vil garantere en mer pålitelig og brukervennlig opplevelse for brukerne dine.