Javascript Prøv å fange

Javascript er et oversettende programmeringsspråk. Akkurat som alle andre språk, må en utvikler eller programmerer ofte bry seg om feilhåndtering. For det meste må en programmerer eller utvikler håndtere feil mens han får tilgang til eller tilordner noen data til databasen. Så feilhåndtering er en viktig del av ethvert programmeringsprosjekt. Det er tre typer feil i programmeringen som en programmerer eller utvikler ofte må møte.

Syntaksfeil - En feil med å skrive kode mot syntaksen til programmeringsspråket. For eksempel mangler du et semikolon eller ikke følger konvensjonen om å opprette og ringe funksjonen.

Logisk feil - En feil i logikkbygningen. For eksempel å implementere feil aritmetisk operasjon, noe som resulterer i feil output.

Kjøretidsfeil - Det oppstod en feil under kjøretiden. Som å ringe en funksjon uten å erklære det.

Feilen vi får i løpet av kjøretiden er også kjent som en unntak. Eksepsjonell håndtering er veldig viktig. Fordi vi ikke kan kaste feilene og feilkodene med en gang. Vi må takle det. Så, i denne artikkelen skal vi ha forståelse for hvordan vi skal håndtere unntak ved hjelp av javascript's try-catch block. Vi vil også lære hvordan du kan kaste en tilpasset melding mot en feil, og hvordan du bruker "endelig" blokken med en prøvefangstblokk.

Syntaks

Syntaksen for å bruke en prøvefangstblokk er veldig enkel og enkel å bruke. Vi kan ganske enkelt bruke prøvefangstblokken slik

prøv
// kode for å prøve eller teste
kaste // kaste en tilpasset feil å fange
fangst (feil)
// kode etter å ha fått en feil
endelig
// kode som uansett kjøres

I denne syntaksen skriver vi først noen kodelinjer i "prøve" -blokken for å teste. Hvis den koden blir utført eller bestått testen. "Prøv" -blokken vil ikke kaste noen feil i "fangst" -blokken og utføre "til slutt" -blokken. Ellers vil det kaste en feil til "fangst" -blokken der vi kan håndtere unntakene i henhold til den gitte feilen. Vi kan også kaste en tilpasset feil i "fangst" -blokken ved å bruke søkeordet "kast". "Endelig" -blokk blir i alle fall utført. Enten “prøve” -blokken kaster noe eller ikke. La oss prøve et par eksempler for å få en bedre forståelse.

Eksempler

Først av alt, for å demonstrere den enkle og grunnleggende virkningen av prøvefangstblokken. Vi prøver å ringe en funksjon uten å erklære den noe sted.

addisjon()

Det vil definitivt kaste en feil i konsollen

Men hvis vi prøver å kalle det i en prøveblokk nå

prøv
addisjon()
fangst (feil)

Det vil ikke vise noen feil i konsollen lenger fordi vi ikke skrev noen kode i fangstblokken for feil. Så vi kan endre og konsolere feilmeldingen i fangstblokken nå.

prøv
addisjon()
fangst (feil)
konsoll.logg ("Feilmelding =>" + feil)

Vi kan se vår tilpassede melding i konsollen mot feilen.

Så dette er den helt grunnleggende bruken av try-catch-blokken. La oss nå lære om å kaste en tilpasset feil i prøveblokken.

Kaste

Anta at vi vil kaste en annen tilpasset feil på grunnlag av forskjellige feil mens vi prøver. Vi kan kaste en tilpasset feil, at “Funksjonsdefinisjon eksisterer ikke." Som dette

prøv
kast ny feil ("Funksjonsdefinisjon eksisterer ikke")
fange (feile)
konsoll.logg ("Feilmelding =>" + feil)

Som du kan se i utgangen, blir feilmeldingen nå endret til vår tilpassede feil kastet.

ProTip

Anta at vi prøver å bruke denne prøvefangsten på en asynkron funksjon. Det vil ikke fungere. Fordi motoren ville ha flyttet til neste linje, utfør den siste blokken, og den asynkrone funksjonen vil bli utført senere. For eksempel hvis vi bruker setTimeout-funksjonen i en prøvefangerblokk.

prøv
setTimeout (() =>
addisjon();
, 3000)
fange (feile)
konsoll.logg ("Feilmelding =>" + feil)
endelig
konsoll.logg ("nådd 'endelig' blokk")

Du kan se at "endelig" blokken blir utført først, og feilen kastes senere hvis vi tar en titt på feilen. Det er ikke feilen fra fangstblokken, men det er en original programmeringsfeil, noe som betyr at fangstblokken ikke blir utført fordi de prøver å blokkere ikke fant noen feil.

Ok! Nå, hvis vi vil få det til å fungere. Vi må bruke prøvefangstblokken inne i setTimeout-funksjonen i stedet for utenfor. Så den virkelige måten å implementere en asynkron funksjon med en prøvefangstblokk ville være slik.

setTimeout (() =>
prøv
addisjon();
fange (feile)
konsoll.logg ("Feilmelding =>" + feil)
endelig
konsoll.logg ("nådd 'endelig' blokk")

, 3000)

Du kan i utgangen observere at etter forsinkelsen på 3 sekunder på grunn av setTimeout-funksjonen. Vi har først fått feilmeldingen fra fangstblokken, og deretter blir "endelig" blokken utført.

Konklusjon

I denne artikkelen har vi lært å implementere prøvefangstblokk trinn for trinn i javascript på en så enkel og dyp måte at enhver nybegynner etter å ha lest denne artikkelen vil kunne bruke den hvor som helst han trenger. Så fortsett å lære og få erfaring i javascript med linuxhint.com. Takk skal du ha!