För det första är det nödvändigt att förstå vad ett fel är och dess typer.
Typer av fel
När du arbetar i vilket programmeringsspråk som helst finns det vanligtvis två typer av fel som kan uppstå:
Driftsfel
Driftsfel uppstår när applikationen möter ett obehandlat undantag eller något problem med koden. Denna typ av fel är vanligtvis svår att upptäcka då det finns många orsaker till dess uppkomst t.ex. minnesläcka, oändliga loopar, felaktig systemdesign, etc.
Ett effektivt sätt att hantera operativa fel är att använda en optimal felhanteringsstrategi för att upptäcka felet i dess ursprung och informera utvecklaren så att det kan åtgärdas i tid.
Funktionsfel
Funktionsfel är de som stoppar applikationskodens normala funktion. Eftersom dessa fel beter sig annorlunda kan de kräva mer brainstorming för att upptäcka deras ursprung eftersom de kan uppträda annorlunda under programmets livscykel.
Ett enkelt fall kan vara ett program där användaren har implementerat fel logik som antingen kan resultera i en oändlig loop och till slut krascha programmet.
Utvecklare måste gräva djupt ner i kodbasen för att identifiera möjliga funktionsfel genom att använda tekniker som felsökning och stackspårning etc.
Nu när vi vet om feltypen som kan uppstå i vårt kodskript är det nödvändigt att ha en förståelse för varför det finns ett behov av att hantera felet.
Uppmaning att hantera fel i Node.js
Innan du förklarar konceptet för hur man hanterar fel i Node.js med try-catch; det är nödvändigt att ha förståelse för varför det finns ett behov av att hantera fel. Hantering av fel i applikationskoden är avgörande för att skapa en pålitlig och förbättrad användarupplevelse-app för användare.
Förbättra användarupplevelsen
Det är en god praxis att undvika användningen av allmänna meddelanden och visa användarvänliga felmeddelanden för en bättre användarupplevelse.
Bygga en starkare kodstiftelse
När felen hanteras optimalt verkar grunden för koden mer realistisk. Den fångar och hanterar de önskade felen effektivt, vilket minskar risken för applikationskrascher.
Buggdetektering
Felhantering gör det enkelt att upptäcka buggar under utvecklingsfasen och ta bort dem så tidigt som möjligt. Detta gör det möjligt för användare att optimera sina applikationer i utvecklingsfasen mer exakt, vilket gör att koden kan flöda utan störningar.
Programkrasch
Att inte hantera felen kan resultera i plötsliga avbrott i kodflödet och i slutändan kraschar programmet. Användningen av en ' försök fånga ” blocket gör att vi kan hantera felen smidigt.
Låt oss nu börja med att titta på strukturen/syntaxen för try-catch-blocket som vi kommer att distribuera i vår kod.
Struktur för try-catch-blocket
Strukturen för try-catch-blocket är ganska enkel och det är basverktyget för att effektivt hantera fel.
Strukturen för try-catch-blocket är:
Prova {} fånga ( fel ) {
trösta. fel ( ) ;
} till sist {
}
Funktionen för ovanstående kod är:
- den ' Prova ”-blocket innehåller all funktionskod och fel kan uppstå i detta block. Om något fel uppstår i detta block utlöser det ' fånga ” block.
- den ' fånga ”-blocket är där alla nödvändiga fel hanteras. Användare kan ändra dess egenskaper och utföra önskade åtgärder.
- den ' till sist ”-blocket är ett valfritt block, och det körs varje gång oavsett om ett fel uppstår eller inte. Den utför rengöringsoperationen.
Förståelsen av try-catch block kan praktiskt förstås av ett fall där vi försöker komma åt en fil som kanske finns eller inte finns. Om det inte finns kan det ge ett fel, för att undvika felet kan användaren hantera det genom att använda sig av try-catch-konceptet.
Filhanteringsfel med 'try-catch'-blocket i Node.js
Låt oss först titta på ett problem utan att använda ett ' försök fånga ” block. I kodexemplet nedan öppnas en fil utan korrekt felhantering:
konst fs = behöva ( 'fs' ) ;konst info = fs. readFileSync ( '/Users/Lenovo/file.txt' ) ;
trösta. logga ( 'En viktig bit kod som bör köras i slutet' ) ;
Förklaringen av koden ovan är:
- ' const fs = require('fs') ” importerar Node.js 'fs' (filsystem)-modulen som låter användaren arbeta med filsystemet, inklusive alla filoperationer som att läsa eller skriva filer.
- ' const data = fs.readFileSync(‘/Users/Lenovo/file.txt’) ” läser innehållet i filen på den angivna sökvägen. den ' readFileSync ” är en synkron operation som innebär att den stoppar den ytterligare kodexekveringen tills filen läses på den angivna sökvägen och informationen lagras i ” info ” variabel.
- ' console.log(“En viktig kod som bör köras i slutet”) ” skriver ut ett meddelande i terminalen men denna rad exekveras inte förrän filen inte läses i föregående steg.
Produktion
Felet som härrör från ovanstående kod kommer att visas som:
Det kan ses att körning av denna kod utan korrekt felhantering resulterar i fel. Refaktorera nu ovanstående kod med hjälp av 'try-catch'-blocket:
konst fs = behöva ( 'fs' ) ;Prova {
konst info = fs. readFileSync ( '/Users/Lenovo/file.txt' ) ;
trösta. logga ( info ) ;
} fånga ( fel ) {
trösta. fel ( ` Fel läsa filen : $ { fel. meddelande } ` ) ;
}
Funktionen för ovanstående kod är:
- Processen för filläsning placeras i ' Prova ” blockera eftersom det finns en chans att felet kan uppstå här.
- ' console.log(info) ” loggar innehållet i filen och skriver ut det i konsolen.
- den ' fånga '-blocket fångar alla möjliga fel som kan uppstå i ' Prova ” blockerar under kodexekvering och loggar felmeddelandet till terminalen.
- ' console.error(`Fel vid läsning av filen: ${error.message}`) ” loggar det specificerade felmeddelandet som erhållits som ett resultat av det fångade felet.
Produktion
Utdata från den effektivt omstrukturerade koden kommer att visa ett optimalt felmeddelande som visas nedan i den bifogade skärmdumpen:
Genom att använda try-catch kan vi hantera eventuella fel som kan uppstå, men för bättre förståelse finns några effektiva metoder som kan vara till hjälp.
Bästa metoder för felhantering
Användaren kan följa följande metoder för att hantera fel i sina programkoder:
Använd försök-fånga klokt
Det är nödvändigt att använda ' försök fånga ” endast där den behöver användas, särskilt i de viktiga delarna av koden där det finns risk för potentiella fel. Att använda för mycket i koden kan göra koden komplex.
Använder asynkron kod
När kod ska hanteras med asynkron kod, försök att använda ' försök fånga ” med löften och asynkron/avvaktar för att optimalt hantera felet.
Logga och rapportera fel
Logga och rapportera alltid det specifika felet korrekt i fångstblocket, eftersom tydliga felmeddelanden hjälper till att identifiera grundorsaken till fel.
Minska komplexiteten
Hantera de situationer där felen inte är kritiska. Att ta bort den specifika delen (om det inte är nödvändigt) kan minska kodkomplexiteten.
Undvika tysta misstag
Skriv koden på ett sätt som visar felmeddelandet där det behövs, annars kommer det att bli ett problem att hantera felet utan korrekt identifiering om felmeddelandet inte anges.
Det handlar om att försöka fånga blocket fungerar och hur det kan användas effektivt för att hantera fel i Node.js.
Slutsats
Att bli skicklig på att hantera fel i Node.js är grundsteget för att utveckla starka och konsekventa applikationer. Den optimala användningen av ' försök fånga ” block tillsammans med olika metoder som asynkrona tekniker och korrekt felloggning kan hjälpa till att skapa stabila och användarvänliga Node.js-applikationer. Den här artikeln har förklarat struktur, praktisk tillämpning och hanteringsmetoder som kan användas enligt användarens krav.