Javascript Prøv at fange

Javascript er et oversættende programmeringssprog. Ligesom ethvert andet sprog skal en udvikler eller programmør ofte være opmærksom på fejlhåndtering. For det meste skal en programmør eller udvikler håndtere fejl, mens de får adgang til eller tildeler nogle data til databasen. Så fejlhåndtering er en vigtig del af ethvert programmeringsprojekt. Der er tre typer fejl i programmeringen, som en programmør eller udvikler ofte skal stå over for.

Syntaks fejl - En fejl ved skrivning af kode mod syntaksen for programmeringssprog. For eksempel mangler du et semikolon eller følger ikke konventionen om at oprette og kalde funktionen.

Logisk fejl - En fejl i den logiske bygning. For eksempel implementering af den forkerte aritmetiske operation, hvilket resulterer i den forkerte output.

Kørselsfejl - Der opstod en fejl under kørselstiden. Som at ringe til en funktion uden at erklære det.

Den fejl, vi får under løbetiden, kaldes også en undtagelse. Enestående håndtering er meget vigtig. Fordi vi ikke kan smide fejlene og fejlkoderne med det samme. Vi er nødt til at håndtere det. Så i denne artikel vil vi have en forståelse af, hvordan man håndterer undtagelser ved hjælp af javascript's try-catch-blok. Vi lærer også, hvordan man smider en brugerdefineret besked mod en fejl, og hvordan man bruger "endelig" blokken med en prøvefangst-blok.

Syntaks

Syntaksen for brug af en prøve-fang-blok er meget enkel og nem at bruge. Vi kan simpelthen bruge try-catch-blokken sådan

prøve
// kode for at prøve eller teste
kast // kast en brugerdefineret fejl at fange
fangst (fejl)
// kode efter at have fået en fejl
langt om længe
// kode, der under alle omstændigheder udføres

I denne syntaks skriver vi først nogle linjer med kode i "prøv" -blokken for at teste. Hvis denne kode bliver udført eller bestået testen med succes. "Try" -blokken kaster ikke nogen fejl i "catch" -blokken og udfører "endelig" -blokken. Ellers kaster det en fejl til "fangst" -blokken, hvor vi kan håndtere undtagelserne i henhold til den givne fejl. Vi kan også kaste en brugerdefineret fejl til "catch" -blokken ved hjælp af "throw" nøgleordet. "Endelig" blok bliver under alle omstændigheder udført. Enten “forsøg” -blokken kaster noget eller ej. Lad os prøve et par eksempler for at få en bedre forståelse.

Eksempler

Først og fremmest for at demonstrere den enkle og grundlæggende funktion af try-catch blokken. Vi forsøger at kalde en funktion uden at erklære den nogen steder.

tilføjelse ()

Det vil helt sikkert kaste en fejl i konsollen

Men hvis vi prøver at kalde det i en prøveblok nu

prøve
tilføjelse ()
fangst (fejl)

Det viser ikke længere nogen fejl i konsollen, fordi vi ikke skrev nogen kode i fangstblokken for fejl. Så vi kan ændre og konsolere fejlmeddelelsen i fangstblokken nu.

prøve
tilføjelse ()
fangst (fejl)
konsol.log ("Fejlmeddelelse =>" + fejl)

Vi kan se vores brugerdefinerede besked i konsollen mod fejlen.

Så dette er den meget grundlæggende brug af try-catch-blokken. Lad os nu lære om at smide en brugerdefineret fejl i prøveblokken.

Kaste

Antag, at vi vil kaste en anden brugerdefineret fejl på basis af forskellige fejl, mens vi prøver. Vi kan kaste en brugerdefineret fejl, at ”Funktionsdefinition findes ikke." Sådan her

prøve
smid ny fejl ("Funktionsdefinition findes ikke")
fange (fejle)
konsol.log ("Fejlmeddelelse =>" + fejl)

Som du kan se i output, ændres fejlmeddelelsen nu til vores tilpassede fejl kastet.

ProTip

Antag, at vi prøver at anvende denne prøveopsætning på en asynkron funktion. Det fungerer ikke. Fordi motoren ville have flyttet til næste linje, skal du udføre den sidste blok, og den asynkrone funktion ville blive udført senere. For eksempel, hvis vi anvender setTimeout-funktionen inde i en prøvefangst-blok.

prøve
setTimeout (() =>
tilføjelse ();
, 3000)
fange (fejle)
konsol.log ("Fejlmeddelelse =>" + fejl)
langt om længe
konsol.log ("nået 'endelig' blok")

Du kan se, at "endelig" blokken bliver udført først, og fejlen kastes senere, hvis vi ser på fejlen. Det er ikke fejlen fra fangstblokken, men det er en original programmeringsfejl, hvilket betyder at fangstblokken ikke bliver udført, fordi de prøver at blokere ikke fandt nogen fejl.

I orden! Nu, hvis vi ønsker at få det til at fungere. Vi er nødt til at anvende prøvefangstblokken inde i setTimeout-funktionen i stedet for udenfor. Så den ægte måde at implementere en asynkron funktion på med en prøvefangstblok ville være sådan.

setTimeout (() =>
prøve
tilføjelse ();
fange (fejle)
konsol.log ("Fejlmeddelelse =>" + fejl)
langt om længe
konsol.log ("nået 'endelig' blok")

, 3000)

Du kan i output konstatere, at efter forsinkelsen på 3 sekunder på grund af funktionen setTimeout. Vi har først fået fejlmeddelelsen fra fangstblokken, og derefter bliver "endelig" blokken udført.

Konklusion

I denne artikel har vi lært at implementere try-catch blok trin for trin i javascript på en så nem og dyb måde, at enhver nybegynder efter at have læst denne artikel vil være i stand til at anvende det hvor som helst han har brug for. Så fortsæt med at lære og få erfaring i javascript med linuxhint.com. tak skal du have!