Ontdek de verschillende soorten fouten die u kunt verwerken en hoe u Express.js kunt gebruiken om hiermee om te gaan.
Belangrijkste leerpunten
- Fouten in Express.js-toepassingen kunnen worden onderverdeeld in syntaxis- en runtimefouten, invoervalidatie- en gebruikersfouten, database- en netwerkgerelateerde fouten en API- en servicefouten van derden.
- Het opvangen en vastleggen van fouten in de console is een eenvoudige manier om fouten af te handelen tijdens ontwikkelings- en foutopsporingsfasen in Express.js. Foutafhandelingspakketten zoals express-error-handler bieden kant-en-klare functionaliteit voor het beheren van en reageren op fouten.
- Het afhandelen van synchrone en asynchrone fouten met behulp van try-catch-blokken is een effectieve techniek in Express.js. Voor asynchrone bewerkingen kan het integreren van de asynchrone en wachtende trefwoorden in try-catch-blokken de foutafhandeling verbeteren. Het creëren van aangepaste middleware voor foutafhandeling zorgt voor een gecentraliseerde en op maat gemaakte benadering van foutbeheer.
In een ideaal scenario bouwt u uw API's en backend-services, implementeert u ze voor productie en leunt u achterover terwijl anderen ze gebruiken. Helaas zullen de programma's die u schrijft in de echte wereld vrijwel zeker fouten en bugs bevatten.
Om deze reden is het bij het ontwikkelen van Express.js API's en backend-services belangrijk om rekening te houden met hoe verschillende fouten kunnen optreden en hoe ze effectief kunnen worden afgehandeld.
Door op dergelijke scenario's te anticiperen, kunt u ervoor zorgen dat uw apps niet alleen storingen effectief afhandelen, maar gebruikers ook een naadloze ervaring bieden.
Veelvoorkomende soorten fouten in Express.js-toepassingen
Bij het ontwikkelen van Express.js-toepassingen zult u verschillende soorten fouten tegenkomen, waaronder:
- Syntax- en runtime-fouten: Syntaxisfouten treden op wanneer er fouten in de syntaxis van de code zitten, wat betekent dat de toepassing niet kan worden uitgevoerd. Runtime-fouten treden daarentegen op wanneer het programma wordt uitgevoerd, meestal als gevolg van onverwachte omstandigheden of onjuiste gegevens.
- Invoervalidatie en gebruikersfouten: Deze fouten treden op wanneer gebruikers onvoldoende of ongeldige gegevens verstrekken tijdens interacties met de applicatie. Deze fouten kunnen zich in verschillende vormen manifesteren, zoals ontbrekende verplichte velden, onjuiste gegevensindelingen of waarden die niet aan specifieke criteria voldoen.
- Database- en netwerkgerelateerde fouten: Database- en netwerkgerelateerde fouten kunnen optreden wanneer er een probleem is met het verbinden met een database of wanneer de communicatie met externe toepassingen via het netwerk mislukt. Deze fouten kunnen bijzonder lastig zijn als uw toepassing afhankelijk is van het netwerk om te werken.
- API- en servicefouten van derden: Er kunnen ook fouten optreden bij interactie met externe API's of services. Bij het doen van verzoeken aan externe systemen kunnen zich verschillende problemen voordoen. De API kan bijvoorbeeld downtime ervaren, antwoorden met fouten als gevolg van ongeldige parameters retourneren of onverwachte gegevensindelingen retourneren.
Er zijn verschillende technieken die u kunt gebruiken om fouten in uw Express.js effectief af te handelen REST API's en backend-services.
1. Fouten opvangen en loggen in de console
Een eenvoudige manier om met fouten om te gaan, is door ze op te vangen en de details naar de console te loggen. Deze aanpak helpt u bij het identificeren van fouten tijdens de ontwikkel- en foutopsporingsfase.
Door het gebruiken van console.fout()kunt u inzicht krijgen in de aard en locatie van fouten binnen uw applicatie. Hier is een codevoorbeeld:
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. Pakketten voor foutafhandeling gebruiken
Express.js biedt verschillende middlewarepakketten voor foutafhandeling om foutbeheer te stroomlijnen. Een van die pakketten is express-error-handler—deze pakketten maken het gemakkelijker om fouten af te handelen en erop te reageren door kant-en-klare functionaliteit te bieden, zoals aangepaste foutmeldingen en foutregistratiefuncties.
Om dit pakket te gebruiken, moet u het in uw project installeren:
npm install express-error-handlerEenmaal geïnstalleerd, kunt u de functies ervan gebruiken om de foutafhandelingsmogelijkheden van uw toepassing te verbeteren.
const errorHandler = require('express-error-handler');
// Register the error-handling middleware
app.use(errorHandler({
static: {
'404': 'path/to/404.html'
}
}));
Stel bijvoorbeeld in het bovenstaande voorbeeld dat een gebruiker een route aanvraagt die niet bestaat. De handlerfunctie zal de gebruiker activeren en omleiden naar een aangepaste 404-foutpagina, 404.html. Dit zorgt ervoor dat de Express.js-toepassing een pagina-niet-gevonden-fout effectief afhandelt.
In wezen bieden deze pakketten een gebruiksvriendelijkere benadering voor het beheer van eventuele fouten.
3. Afhandelen van synchrone en asynchrone fouten met behulp van Try-Catch-blokken
Behandeling synchrone en asynchrone programmering fouten met behulp van try-catch-blokken is een effectieve techniek in Express.js. Voor synchrone code kunt u fouten beheren door de potentieel foutgevoelige sectie in een try-catch-blok te plaatsen.
Hier is een codevoorbeeld met try-catch-blokken die in gebruik zijn:
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.' });
}
});Bij het werken met asynchrone bewerkingen zoals databasequery's of Axios gebruikenom API's te gebruiken, zijn alleen try-catch-blokken mogelijk niet voldoende. In dergelijke gevallen kunt u nu de asynchroon en wacht af trefwoorden binnen de blokken om fouten efficiënter af te handelen.
Hier is wat voorbeeldcode:
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. Aangepaste middleware voor foutafhandeling maken
Op maat gemaakte middleware voor foutafhandeling stelt u in staat om te definiëren hoe uw programma omgaat met fouten en de bijbehorende reacties, in overeenstemming met de vereisten van uw toepassing.
Door middlewarefuncties voor foutafhandeling te creëren, kunt u foutbeheer centraliseren en aanpassen, waardoor u verzekerd bent van een meer georganiseerde en op maat gemaakte aanpak voor het afhandelen van fouten in de hele toepassing.
Hier is een voorbeeld van een aangepaste middleware-functiecode:
// 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);
In dit voorbeeld is de notFoundHandler functie controleert de bron parameter in de verzoek-URL. Afhankelijk van de opgegeven waarde reageert de handlerfunctie met aangepaste foutberichten voor verschillende soorten bronnen, zoals gebruikers en producten.
Voor elke andere bron die niet expliciet wordt afgehandeld, wordt een generiek foutbericht weergegeven. Als alternatief kunt u binnen deze middleware er ook voor kiezen om gebruikers naar aangepaste foutpagina's te leiden die hen helpen bij het oplossen van de problemen die ze tegenkwamen.
Door deze aangepaste middleware voor foutafhandeling te gebruiken, kunt u foutbeheer en reacties op verschillende situaties afstemmen, waardoor foutafhandeling specifieker en informatiever wordt.
In een productieomgeving is het essentieel om foutregistratie en monitoring te implementeren om toepassingsfouten bij te houden. Enkele effectieve hulpmiddelen die u kunt gebruiken, zijn onder meer Winston En Morgan, onder andere. Deze tools registreren fouten in een bestand, een gecentraliseerde server of een monitoringplatform, zodat u problemen snel kunt identificeren en oplossen.
Hier is een voorbeeld van hoe u Winston kunt gebruiken in een Express.js-toepassing voor foutregistratie:
const winston = require('winston');
const expressWinston = require('express-winston');
app.use(expressWinston.errorLogger({
// Error logging middleware using Winston
}));
Foutbeheer in backend-applicaties
Het implementeren van efficiënte foutbeheertechnieken en faalveilige procedures is essentieel bij het bouwen van robuuste backend-applicaties.
In Express.js-toepassingen is het belangrijk om te anticiperen op, plannen voor en implementeren van effectieve foutafhandelingstechnieken waarmee u snel fouten kunt identificeren, beheren en erop kunt reageren. Dit garandeert een betrouwbaardere en gebruiksvriendelijkere ervaring voor uw gebruikers.