Ten eerste is het noodzakelijk om te begrijpen wat een fout is en welke soorten deze zijn.
Fouttypen
Bij het werken in welke programmeertaal dan ook kunnen er over het algemeen twee soorten fouten optreden:
Operationele fout
Een operationele fout treedt op wanneer de toepassing wordt geconfronteerd met een onverwerkte uitzondering of een probleem in de code. Dit type fout is meestal moeilijk te herkennen, omdat er talloze oorzaken zijn voor de oorsprong ervan, b.v. geheugenlek, eindeloze lussen, onnauwkeurig systeemontwerp, enz.
Een efficiënte manier om met operationele fouten om te gaan, is door gebruik te maken van een optimale foutafhandelingsstrategie om de fout bij de oorsprong ervan op te sporen en de ontwikkelaar te informeren, zodat deze op tijd kan worden verholpen.
Functionele fout
Functionele fouten zijn fouten die de normale werking van applicatiecode stopzetten. Omdat deze fouten zich anders gedragen, is er mogelijk meer brainstormwerk nodig om de oorsprong ervan te achterhalen, omdat ze zich tijdens de levenscyclus van de applicatie anders kunnen gedragen.
Een eenvoudig geval kan een programma zijn waarin de gebruiker de verkeerde logica heeft geïmplementeerd, wat kan resulteren in een oneindige lus en uiteindelijk het programma kan laten crashen.
Ontwikkelaars moeten diep in de codebase graven om mogelijke functionele fouten te identificeren door technieken als debugging en stacktraces enz. te gebruiken.
Nu we weten welk type fout kan optreden in ons codescript, is het noodzakelijk om te begrijpen waarom het nodig is om de fout af te handelen.
Drang om fouten in Node.js af te handelen
Voordat we het concept uitleggen van hoe fouten in Node.js moeten worden afgehandeld met behulp van try-catch; het is noodzakelijk om te begrijpen waarom er met fouten moet worden omgegaan. Het afhandelen van fouten in de applicatiecode is cruciaal voor het opzetten van een betrouwbare en verbeterde app voor gebruikerservaring.
Verbetering van de gebruikerservaring
Het is een goede gewoonte om het gebruik van algemene berichten te vermijden en gebruiksvriendelijke foutmeldingen weer te geven voor een betere gebruikerservaring.
Bouwen aan een sterkere codebasis
Wanneer de fouten optimaal worden afgehandeld, lijkt de basis van de code realistischer. Het registreert en verwerkt op efficiënte wijze de gewenste fouten, waardoor het risico op applicatiecrashes wordt verminderd.
Bugdetectie
Foutafhandeling maakt het gemakkelijk om bugs tijdens de ontwikkelingsfase op te sporen en deze zo vroeg mogelijk te verwijderen. Hierdoor kunnen gebruikers hun applicaties in de ontwikkelingsfase nauwkeuriger optimaliseren, waardoor de code zonder enige verstoring kan stromen.
Applicatiecrash
Het niet afhandelen van de fouten kan leiden tot een plotselinge verstoring van de codestroom en uiteindelijk tot het crashen van de applicatie. Het gebruik van een “ proberen te vangen ”-blok stelt ons in staat om de fouten soepel af te handelen.
Laten we nu beginnen met te kijken naar de structuur/syntaxis van het try-catch-blok dat we in onze code gaan implementeren.
Structuur van try-catch-blok
De structuur van het try-catch-blok is vrij eenvoudig en het is het basishulpmiddel om fouten effectief af te handelen.
De structuur voor het try-catch-blok is:
poging {} vangst ( fout ) {
troosten. fout ( ) ;
} Eindelijk {
}
De werking van bovenstaande code is:
- De ' poging ”-blok bevat alle functionerende code en er kunnen fouten optreden in dit blok. Als er een fout optreedt in dit blok, wordt de melding “ vangst ” blok.
- De ' vangst ”-blok is waar alle noodzakelijke fouten worden afgehandeld. Gebruikers kunnen de eigenschappen ervan wijzigen en de gewenste acties uitvoeren.
- De ' Eindelijk ”-blok is een optioneel blok en wordt elke keer uitgevoerd, ongeacht of er een fout optreedt of niet. Het voert de opruimactie uit.
Het begrip try-catch-blok kan praktisch worden begrepen door een geval waarin we proberen toegang te krijgen tot een bestand dat al dan niet bestaat. Als het niet bestaat, kan het een foutmelding geven. Om de fout te voorkomen, kan de gebruiker dit oplossen door gebruik te maken van het try-catch-concept.
Bestandsverwerkingsfouten met behulp van het ‘try-catch’-blok in Node.js
Laten we eerst eens naar een probleem kijken zonder een “ proberen te vangen ” blok. In het onderstaande codevoorbeeld wordt een bestand geopend zonder de juiste foutafhandeling:
const fs = vereisen ( 'fs' ) ;const informatie = fs. leesFileSync ( '/Gebruikers/Lenovo/bestand.txt' ) ;
troosten. loggen ( 'Een belangrijk stukje code dat aan het einde moet worden uitgevoerd' ) ;
De uitleg door de bovenstaande code is:
- “ const fs = vereisen(‘fs’) ” importeert de Node.js ‘fs’-module (bestandssysteem) waarmee de gebruiker met het bestandssysteem kan werken, inclusief alle bestandsbewerkingen zoals het lezen of schrijven van bestanden.
- “ const data = fs.readFileSync(‘/Users/Lenovo/file.txt’) ”Leest de inhoud van het bestand op het opgegeven pad. De ' leesFileSync ” is een synchrone bewerking, wat betekent dat de verdere uitvoering van de code wordt gestopt totdat het bestand op het opgegeven pad is gelezen en informatie is opgeslagen in de “ informatie Variabel.
- “ console.log(“Een belangrijk stuk code dat aan het einde moet worden uitgevoerd”) ” drukt een bericht af in de terminal, maar deze regel wordt pas uitgevoerd als het bestand in de vorige stap niet is gelezen.
Uitvoer
De fout die voortvloeit uit de bovenstaande code zal verschijnen als:
Het is duidelijk dat het uitvoeren van deze code zonder de juiste foutafhandeling tot fouten leidt. Refactoreer nu de bovenstaande code met behulp van het “try-catch” -blok:
const fs = vereisen ( 'fs' ) ;poging {
const informatie = fs. leesFileSync ( '/Gebruikers/Lenovo/bestand.txt' ) ;
troosten. loggen ( informatie ) ;
} vangst ( fout ) {
troosten. fout ( ` Fout het bestand lezen : $ { fout. bericht } ` ) ;
}
De werking van bovenstaande code is:
- Het proces van het lezen van bestanden wordt geplaatst in de “ poging ” blokkeren omdat de kans bestaat dat de fout hier optreedt.
- “ console.log(info) ”Logt de inhoud van het bestand en drukt deze af in de console.
- De ' vangst ”-blok vangt elke mogelijke fout op die kan optreden in de “ poging ”blok tijdens het uitvoeren van de code en registreert de foutmelding naar de terminal.
- “ console.error(`Fout bij het lezen van het bestand: ${error.message}`) ” registreert het opgegeven foutbericht dat is verkregen als gevolg van de onderschepte fout.
Uitvoer
De uitvoer van de efficiënt gerefactoreerde code zal een optimaal foutbericht weergeven, zoals hieronder weergegeven in de bijgevoegde schermafbeelding:
Door gebruik te maken van de try-catch kunnen we omgaan met de mogelijke fout die kan optreden, maar voor een beter begrip worden enkele efficiënte praktijken toegepast die nuttig kunnen zijn.
Beste praktijken voor foutafhandeling
Gebruikers kunnen de volgende werkwijzen volgen om fouten in hun applicatiecodes af te handelen:
Maak verstandig gebruik van try-catch
Het is noodzakelijk om “ proberen te vangen ” alleen daar waar het moet worden gebruikt, vooral in de belangrijke delen van de code waar het risico op mogelijke fouten bestaat. Als u te veel in de code gebruikt, kan de code complex worden.
Met behulp van asynchrone code
Wanneer code met asynchrone code moet worden afgehandeld, probeer dan “ proberen te vangen ” met beloften en async/wachten om de fout optimaal af te handelen.
Fouten registreren en rapporteren
Registreer en rapporteer de specifieke fout altijd goed in het catch-blok, omdat duidelijke foutmeldingen helpen de oorzaak van fouten te identificeren.
Het verminderen van complexiteit
Behandel de situaties waarin de fouten niet kritiek zijn. Het verwijderen van dat specifieke gedeelte (als het niet nodig is) kan de complexiteit van de code verminderen.
Het vermijden van stille fouten
Schrijf de code zo dat de foutmelding waar nodig wordt weergegeven, anders wordt het een probleem om de fout af te handelen zonder de juiste identificatie als de foutmelding niet wordt aangegeven.
Dat gaat allemaal over de werking van het try-catch-blok en hoe het efficiënt kan worden gebruikt om fouten in Node.js af te handelen.
Conclusie
Vaardig worden in het omgaan met fouten in Node.js is de basisstap voor het ontwikkelen van sterke en consistente applicaties. Het optimaal benutten van de “ proberen te vangen ”blok samen met verschillende praktijken zoals asynchrone technieken en een goede foutregistratie kunnen helpen bij het opzetten van stabiele en gebruiksvriendelijke Node.js-applicaties. In dit artikel worden de structuur, de praktische toepassing en de hanteringspraktijken uitgelegd die kunnen worden toegepast volgens de gebruikersvereisten.