JavaScript Promise Feilhåndtering

Asynkron kode kan bruke løfter for å bruke strukturert feilhåndtering. Mens du bruker løfter, kan du spesifisere en feilbehandler til "deretter()”Metode eller bruk en“å fange()”Blokk. I likhet med unntakene som er lagt til i den vanlige koden, når et løfte blir avvist, ser det ut for den nærmeste feilbehandleren, der kastet feil blir ført som en andre parameter til da () -metoden eller feilbehandleren passerer den til Catch () -metoden.

Denne oppskrivningen vil diskutere JavaScript Promise Feilhåndtering ved hjelp av passende eksempler. Så la oss starte!

JavaScript Promise Feilhåndtering

Løfter brukes til å håndtere utførelsesstrømmen i et program. Chaining Promises er også nyttig når du utfører en serie asynkrone funksjoner, der hver er avhengig av den tidligere funksjonen. I et løfte kan du bruke to metoder for håndteringsfeil som er "deretter()”Metode og“å fange()”Blokk.

JavaScript Promise Feilhåndtering ved bruk av da () -metoden

“deretter()”Metoden utføres når et løfte blir oppfylt eller avvist. Hvis det ekstra løftet er oppfylt med hell, vil den relaterte behandlerfunksjonen kjøres. Imidlertid er feilbehandleren for "deretter()”Metoden vil bli utført i tilfelle av avvisning av løfte.

Eksempel: JavaScript Promise Feilhåndtering ved bruk av da () -metoden
I det undergitte eksemplet har vi lagt til “deretter()”Metode, som omfatter to tilbakeringinger, den ene er suksessbehandlerfunksjonen og den andre er for feilhåndtering:

const PromiseObj = nytt løfte ((Løs, avvis) =>
setTimeout (() =>
avvis ("en feil oppstår");
, 2000));
PromiseObj.da ((svar) =>
konsoll.logg (svar);, (feil) =>
konsoll.logg (feil); );

Utførelse av det ovennevnte programmet vil vise deg følgende utdata:

Som du kan se fra utdataene, den spesifiserte behandleren av “deretter()”Metoden fungerer perfekt; Imidlertid har det også noen ulemper. For eksempel kan vi møte enhver feil i suksessbehandleren, men den ekstra suksessbehandleren kan ikke håndtere det. Når det gjelder bruk av den da () -metoden, må du også skrive en feilbehandler for hver "da ()" -blokk. I en slik situasjon kan du bruke “å fange()”For å overvinne de nevnte ulempene.

Eksempel 1: JavaScript Promise Feilhåndtering ved bruk av fangst () -blokk
Nå vil vi legge til en fangst () for å håndtere feilen eller avvisningstilstanden for løftet:

const PromiseObj = nytt løfte ((Løs, avvis) =>
setTimeout (() =>
avvis ("en feil oppstår");
, 2000));
PromiseObj.da ((svar) =>
konsoll.logg (svar);).fangst ((feil) =>
konsoll.logg (feil); );

Når et av de ekstra løftene blir avvist, blir den gjenværende løftekjeden avsluttet. Det er grunnen til at bare en konsolllogg utføres:

Eksempel 2: JavaScript Promise Feilhåndtering ved bruk av fangst () Block
I det følgende eksemplet vil først og fremst fremmede Promise -objekt godta “skredder”Som navneargument og viser den deretter på konsollen. Etter det vil funksjonen sjekke om løftefunksjonen er oppfylt eller avvist og utføre den ekstra koden deretter:

const oppmøte = funksjon (navn)
Returner nytt løfte ((Løs, avvis) =>
if (name === "louis")
Return Reject ("Louis er til stede");
annet
setTimeout (() =>
Retur Resolve (navn);
, 2000);

);
Oppmøte ("Taylor")
.da ((data) =>
konsoll.logg (data);
returmøte ("Louis"); )
.da ((data) =>
konsoll.logg (data);
returmøte ("Stepheny"); )
.fangst ((feil) =>
konsoll.logg (feil); )

JavaScript Promise.All () Metode

Løftet.Alle () JavaScript -metoden lar deg utføre flere asynkrone operasjoner samtidig. I et slikt scenario vil tilbakeringingen bli utført når løftet.All metode fullfører de spesifiserte operasjonene.

Eksempel: Bruke JavaScript Promise.All () Metode
Det oppgitte eksemplet vil samtidig utføre løftene “x”,“y”, Og“z”. Etter det vil alle løftene komme tilbake "Navn”:

const PromiseObj = funksjon (navn)
Returner nytt løfte ((Løs, avvis) =>
setTimeout (() =>
Retur Resolve (navn);
, 2000);
);
const x = PromiseObj ("Taylor");
const y = PromiseObj ("Stepheny");
const z = PromiseObj ("maks");
Love.Alle ([x, y, z])
.da ((data) =>
konsoll.logg (data); );

Utførelsen vil bare ta to sekunder for å vise tre navn, mens i tilfelle løftekjetting vil den kreve seks sekunder:

JavaScript Promise.Race () Metode

Hvis du vil utføre tilbakeringingen så snart den første asynkrone operasjonen er fullført, kan du bruke "Love.løp()”Metode.

Eksempel: Bruke JavaScript Promise.Race () Metode
Vi har skapt tre løfterobjekter “x”,“y”, Og“z”Med navn og tidsargumenter overført til“PromiseObj ()”Funksjon:

const PromiseObj = funksjon (navn, tid)
Returner nytt løfte ((Løs, avvis) =>
setTimeout (() =>
Retur Resolve (navn);
, tid);
);

Her, “Marie”Har minst tid for“1”For det andre, så hun kommer til å vinne løpet og navnet hennes blir vist som output:

const x = PromiseObj ("Taylor", 3000);
const y = PromiseObj ("Stepheny", 2000);
const z = PromiseObj ("Marie", 1000);
Love.Race ([x, y, z])
.da ((data) =>
konsoll.logg (data); )
.fangst ((feil) =>
konsoll.logg (feil);
)

Den ovennevnte output betyr at vi har implementert løftet med hell.Race () Metode for å utføre flere operasjoner samtidig.

Konklusjon

Bruker å fange() og deretter() Metoder, kan du håndtere feilen som kastes eller avvise () Ring i Promise Chaining. For å håndtere feil er det å foretrekke å legge til en fangst () -metode i koden din. Feilbehandleren undersøker deretter koden og håndterer dem deretter. Denne oppskrivningen forklarte løftfeilhåndteringen i JavaScript ved hjelp av passende eksempler.