Opdag de forskellige typer fejl, du kan håndtere, og hvordan du kan bruge Express.js til at håndtere dem.

Nøgle takeaways

  • Fejl i Express.js-applikationer kan kategoriseres i syntaks- og runtime-fejl, inputvalidering og brugerfejl, database- og netværksrelaterede fejl og tredjeparts API- og servicefejl.
  • At fange og logge fejl til konsollen er en enkel måde at håndtere fejl under udviklings- og fejlfindingsfaser i Express.js. Fejlhåndteringspakker som express-error-handler giver funktionalitet, der er klar til brug, til håndtering og reaktion på fejl.
  • Håndtering af synkrone og asynkrone fejl ved hjælp af try-catch-blokke er en effektiv teknik i Express.js. For asynkrone operationer kan integration af asynkron- og afvent-nøgleord i try-catch-blokke forbedre fejlhåndteringen. Oprettelse af tilpasset fejlhåndteringsmiddleware giver mulighed for en centraliseret og skræddersyet tilgang til fejlhåndtering.

I et ideelt scenarie bygger du dine API'er og backend-tjenester, implementerer dem til produktion og læner dig derefter tilbage og slapper af, mens andre bruger dem. Desværre, i den virkelige verden, vil de programmer, du skriver, næsten helt sikkert indeholde fejl og fejl.

Af denne grund, når du udvikler Express.js API'er og backend-tjenester, er det vigtigt at tage hensyn til, hvordan forskellige fejl kan opstå, og hvordan man håndterer dem effektivt.

Ved at forudse sådanne scenarier kan du sikre, at dine apps ikke kun håndterer fejl effektivt, men også giver brugerne en problemfri oplevelse.

Almindelige typer af fejl i Express.js-applikationer

Når du udvikler Express.js-applikationer, vil du støde på forskellige typer fejl, herunder:

  1. Syntaks og runtime fejl: Syntaksfejl opstår, når der er fejl i kodens syntaks, hvilket betyder, at applikationen ikke kan køre. Kørselsfejl opstår derimod, når programmet kører, typisk på grund af uventede forhold eller forkerte data.
  2. Inputvalidering og brugerfejl: Disse fejl opstår, når brugere leverer utilstrækkelige eller ugyldige data under interaktioner med applikationen. Disse fejl kan vise sig i forskellige former, såsom manglende obligatoriske felter, forkerte dataformater eller værdier, der ikke opfylder specifikke kriterier.
  3. Database- og netværksrelaterede fejl: Database- og netværksrelaterede fejl kan opstå, når der er et problem med at oprette forbindelse til en database, eller når kommunikation med eksterne applikationer over netværket mislykkes. Disse fejl kan være særligt besværlige, hvis din applikation er afhængig af, at netværket fungerer.
  4. Tredjeparts API og servicefejl: Der kan også opstå fejl ved interaktion med eksterne API'er eller tjenester. Ved anmodninger til eksterne systemer kan der opstå forskellige problemer. For eksempel kan API'en opleve nedetid, returnere svar med fejl på grund af ugyldige parametre eller returnere uventede dataformater.

Der er forskellige teknikker, du kan bruge til effektivt at håndtere fejl i din Express.js REST API'er og backend-tjenester.

1. Fange og logge fejl til konsollen

En ligetil måde at håndtere fejl på er at fange dem og logge detaljerne på konsollen. Denne tilgang hjælper dig med at identificere fejl under udviklings- og fejlretningsfaserne.

Ved hjælp af console.error(), kan du få indsigt i arten og placeringen af ​​fejl i din applikation. 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. Brug af fejlhåndteringspakker

Express.js tilbyder adskillige fejlhåndterings-middleware-pakker for at strømline fejlhåndtering. En sådan pakke er udtrykke-fejl-handler— Disse pakker gør det nemmere at håndtere og reagere på fejl ved at levere funktionalitet, der er klar til brug, såsom brugerdefinerede fejlmeddelelser og fejllogningsfunktioner.

For at bruge denne pakke skal du installere den i dit projekt:

npm install express-error-handler

Når den er installeret, kan du bruge dens funktioner til at forbedre din applikations fejlhåndteringsfunktioner.

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

Antag for eksempel i eksemplet ovenfor, at en bruger anmoder om en rute, der ikke eksisterer. Håndteringsfunktionen vil udløse og omdirigere brugeren til en tilpasset 404-fejlside, 404.html. Dette sikrer, at Express.js-applikationen effektivt håndterer en side-ikke-fundet fejl.

Grundlæggende giver disse pakker en mere brugervenlig tilgang til håndtering af fejl, der kan opstå.

3. Håndtering af synkrone og asynkrone fejl ved hjælp af Try-Catch-blokke

Håndtering synkron og asynkron programmering fejl ved brug af try-catch-blokke er en effektiv teknik i Express.js. For synkron kode kan du håndtere fejl ved at pakke den potentielt fejltilbøjelige sektion ind i en try-catch-blok.

Her er et kodeeksempel, der viser try-catch blokke i brug:

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 arbejder med asynkrone operationer såsom databaseforespørgsler eller ved hjælp af Axiosfor at forbruge API'er er try-catch-blokke måske ikke nok. I sådanne tilfælde kan du nu integrere asynkron og afvent nøgleord inden for blokkene for at håndtere fejl mere effektivt.

Her er et eksempel på kode:

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. Oprettelse af brugerdefineret middel til fejlhåndtering

Brugerdefineret fejlhåndteringsmiddleware giver dig mulighed for at definere, hvordan dit program håndterer fejl og deres tilsvarende svar, i henhold til din applikations krav.

Ved at skabe fejlhåndterings-middleware-funktioner kan du centralisere og tilpasse fejlhåndtering, hvilket sikrer en mere organiseret og skræddersyet tilgang til håndtering af fejl på tværs af hele applikationen.

Her er et eksempel på en brugerdefineret middleware-funktionskode:

// 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 eksempel er notFoundHandler funktion kontrollerer ressource parameter i anmodningens URL. Afhængigt af den angivne værdi, reagerer handlerfunktionen med brugerdefinerede fejlmeddelelser for forskellige typer ressourcer, såsom brugere og produkter.

For enhver anden ressource, der ikke eksplicit håndteres, giver den en generisk fejlmeddelelse. Alternativt kan du inden for denne middleware også vælge at dirigere brugere til brugerdefinerede fejlsider, som hjælper dem med at løse de problemer, de stødte på.

Ved at bruge denne brugerdefinerede fejlhåndteringsmiddleware kan du skræddersy fejlhåndtering og svar til forskellige situationer, hvilket gør fejlhåndtering mere specifik og informativ.

I et produktionsmiljø er det vigtigt at implementere fejllogning og overvågning for at holde styr på applikationsfejl. Nogle effektive værktøjer, du kan bruge, omfatter Winston og Morgan, blandt andre. Disse værktøjer logger fejl til en fil, en centraliseret server eller en overvågningsplatform, så du hurtigt kan identificere og løse problemer.

Her er et eksempel på, hvordan du kan bruge Winston i en Express.js-applikation til fejllogning:

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

Fejlhåndtering i backend-applikationer

Implementering af effektive fejlhåndteringsteknikker og fejlsikre procedurer er afgørende for at opbygge robuste backend-applikationer.

I Express.js-applikationer er det vigtigt at forudse, planlægge og implementere effektive fejlhåndteringsteknikker, der giver dig mulighed for hurtigt at identificere, administrere og reagere på fejl. Dette vil garantere en mere pålidelig og brugervenlig oplevelse for dine brugere.