Upptäck de olika typerna av fel du kan hantera och hur du kan använda Express.js för att hantera dem.
Viktiga takeaways
- Fel i Express.js-applikationer kan kategoriseras i syntax- och körtidsfel, indatavalidering och användarfel, databas- och nätverksrelaterade fel och tredjeparts API- och tjänstfel.
- Att fånga och logga fel till konsolen är ett enkelt sätt att hantera fel under utvecklings- och felsökningsfaser i Express.js. Felhanteringspaket som express-error-handler tillhandahåller funktionalitet som är färdig att använda för att hantera och svara på fel.
- Att hantera synkrona och asynkrona fel med hjälp av try-catch-block är en effektiv teknik i Express.js. För asynkrona operationer kan integrering av asynkron- och await-nyckelord i try-catch-block förbättra felhanteringen. Att skapa anpassad mellanprogram för felhantering möjliggör en centraliserad och skräddarsydd metod för felhantering.
I ett idealiskt scenario bygger du dina API: er och backend-tjänster, distribuerar dem till produktion och sedan luta dig tillbaka och koppla av medan andra använder dem. Tyvärr, i den verkliga världen, kommer programmen du skriver nästan säkert att innehålla fel och buggar.
Av denna anledning, när du utvecklar Express.js API: er och backend-tjänster, är det viktigt att ta hänsyn till hur olika fel kan uppstå och hur man hanterar dem effektivt.
Genom att förutse sådana scenarier kan du säkerställa att dina appar inte bara hanterar fel effektivt utan också ger användarna en sömlös upplevelse.
Vanliga typer av fel i Express.js-program
När du utvecklar Express.js-applikationer kommer du att stöta på olika typer av fel, inklusive:
- Syntax- och körtidsfel: Syntaxfel uppstår när det finns fel i kodens syntax, vilket innebär att programmet inte kan köras. Runtime-fel uppstår å andra sidan när programmet körs, vanligtvis på grund av oväntade förhållanden eller felaktiga data.
- Inmatningsvalidering och användarfel: Dessa fel uppstår när användare tillhandahåller otillräckliga eller ogiltiga data under interaktioner med programmet. Dessa fel kan visa sig i olika former, till exempel saknade obligatoriska fält, felaktiga dataformat eller värden som inte uppfyller specifika kriterier.
- Databas- och nätverksrelaterade fel: Databas- och nätverksrelaterade fel kan uppstå när det finns problem med att ansluta till en databas eller när kommunikationen med externa applikationer över nätverket misslyckas. Dessa fel kan vara särskilt besvärliga om din applikation förlitar sig på att nätverket fungerar.
- Tredjeparts API och tjänstfel: Fel kan också uppstå vid interaktion med externa API: er eller tjänster. Vid förfrågningar till externa system kan olika problem uppstå. Till exempel kan API: et uppleva driftstopp, returnera svar med fel på grund av ogiltiga parametrar eller returnera oväntade dataformat.
Det finns olika tekniker du kan använda för att effektivt hantera fel i din Express.js REST API: er och backend-tjänster.
1. Fånga och logga fel till konsolen
Ett enkelt sätt att hantera fel är att fånga upp dem och logga detaljerna till konsolen. Detta tillvägagångssätt hjälper dig att identifiera fel under utvecklings- och felsökningsfaserna.
Genom att använda console.error(), kan du få insikter om arten och platsen för fel i din applikation. Här är ett kodexempel:
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. Använda felhanteringspaket
Express.js erbjuder flera mellanprogrampaket för felhantering för att effektivisera felhanteringen. Ett sådant paket är express-felhanterare— Dessa paket gör det enklare att hantera och svara på fel genom att tillhandahålla funktionalitet som är färdig att använda, såsom anpassade felmeddelanden och felloggningsfunktioner.
För att använda det här paketet måste du installera det i ditt projekt:
npm install express-error-handlerNär den väl har installerats kan du använda dess funktioner för att förbättra din applikations felhanteringsmöjligheter.
const errorHandler = require('express-error-handler');
// Register the error-handling middleware
app.use(errorHandler({
static: {
'404': 'path/to/404.html'
}
}));
Anta till exempel i exemplet ovan att en användare begär en rutt som inte finns. Hanterarfunktionen kommer att utlösa och omdirigera användaren till en anpassad 404-felsida, 404.html. Detta säkerställer att Express.js-applikationen effektivt hanterar ett fel på sidan som inte hittades.
I huvudsak ger dessa paket ett mer användarvänligt sätt att hantera fel som kan uppstå.
3. Hantera synkrona och asynkrona fel med hjälp av Try-Catch-block
Hantering synkron och asynkron programmering fel som använder try-catch-block är en effektiv teknik i Express.js. För synkron kod kan du hantera fel genom att linda in det potentiellt felbenägna avsnittet i ett försöksfångstblock.
Här är ett kodexempel som visar test-catch-block som används:
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 man arbetar med asynkrona operationer som databasfrågor eller använder AxiosFör att konsumera API: er kanske det inte räcker med försök-fångst-block. I sådana fall kan du nu integrera asynkronisera och vänta nyckelord inom blocken för att hantera fel mer effektivt.
Här är några exempelkoder:
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. Skapa anpassad mellanprogram för felhantering
Med anpassad mellanprogramvara för felhantering kan du definiera hur ditt program hanterar fel och deras motsvarande svar, enligt din applikations krav.
Genom att skapa mellanprogramfunktioner för felhantering kan du centralisera och anpassa felhanteringen, vilket säkerställer en mer organiserad och skräddarsydd metod för att hantera fel i hela applikationen.
Här är ett exempel på en anpassad middleware-funktionskod:
// 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 det här exemplet är notFoundHandler funktionen kontrollerar resurs parametern i webbadressen för begäran. Beroende på det angivna värdet svarar hanterarfunktionen med anpassade felmeddelanden för olika typer av resurser, såsom användare och produkter.
För alla andra resurser som inte explicit hanteras ger den ett allmänt felmeddelande. Alternativt, inom denna mellanprogramvara, kan du också välja att dirigera användare till anpassade felsidor som hjälper dem att lösa de problem de stött på.
Genom att använda denna anpassade mellanprogramvara för felhantering kan du skräddarsy felhantering och svar till olika situationer, vilket gör felhanteringen mer specifik och informativ.
I en produktionsmiljö är det viktigt att implementera felloggning och övervakning för att hålla reda på applikationsfel. Några effektiva verktyg du kan använda inkluderar Winston och Morgan, bland andra. Dessa verktyg loggar fel till en fil, en centraliserad server eller en övervakningsplattform, så att du snabbt kan identifiera och lösa problem.
Här är ett exempel på hur du kan använda Winston i en Express.js-applikation för felloggning:
const winston = require('winston');
const expressWinston = require('express-winston');
app.use(expressWinston.errorLogger({
// Error logging middleware using Winston
}));
Felhantering i Backend-applikationer
Implementering av effektiva felhanteringstekniker och felsäkra procedurer är avgörande för att bygga robusta backend-applikationer.
I Express.js-applikationer är det viktigt att förutse, planera för och implementera effektiva felhanteringstekniker som gör att du snabbt kan identifiera, hantera och svara på fel. Detta kommer att garantera en mer pålitlig och användarvänlig upplevelse för dina användare.
