TypeScript Academy · leksjon

Feilhåndtering i asynkron TypeScript-kode

Håndter asynkrone feil med typede omslag og verktøyfunksjoner.

Leksjon 4 av 413 trinn

Feilhåndtering i asynkron TypeScript-kode er en gratis leksjon i TypeScript Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i TypeScript Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.

Velkommen

Asynkrone funksjoner gjør feilhåndtering mer kompleks. TypeScript sørger for at du håndterer Promise-avvisninger på riktig måte.

Try-catch med async/await

Omslutt await-kall i try-catch for å håndtere Promise-avvisninger.

async function loadUser(id: number): Promise<User> {
  try {
    return await api.getUser(id);
  } catch (err: unknown) {
    if (err instanceof Error) throw new AppError(err.message);
    throw new AppError('Unknown error');
  }
}

Feil i Promise.all

Promise.all avvises ved den første avvisningen. Omslutt kallet i try-catch.

try {
  const [user, posts] = await Promise.all([getUser(id), getPosts(id)]);
} catch (err) { /* one or both failed */ }

Promise.allSettled

allSettled returnerer både vellykkede resultater og feil uten å kaste unntak.

const results = await Promise.allSettled([getUser(1), getPosts(1)]);
results.forEach(r => {
  if (r.status === 'fulfilled') console.log(r.value);
  else console.error(r.reason);
});

Typet asynkront resultat

Kombiner asynkronitet med Result-mønsteret for eksplisitt feilhåndtering.

async function safeGet<T>(fn: () => Promise<T>): Promise<Result<T>> {
  try { return { ok: true, value: await fn() }; }
  catch (e) { return { ok: false, error: e as Error }; }
}

Ubehandlede avvisninger

Lytt etter ubehandlede avvisninger i Node.js for å forhindre krasj.

process.on('unhandledRejection', (reason: unknown) => {
  console.error('Unhandled rejection:', reason);
  process.exit(1);
});

Tidsavbrudd med Promise.race

Implementer et typet mønster for tidsavbrudd med Promise.race.

function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
  const timeout = new Promise<never>((_, reject) =>
    setTimeout(() => reject(new Error('Timeout')), ms));
  return Promise.race([promise, timeout]);
}

Mønster for nytt forsøk

Implementer typede asynkrone nye forsøk med typede feil.

async function retry<T>(fn: () => Promise<T>, times: number): Promise<T> {
  for (let i = 0; i < times; i++) {
    try { return await fn(); } catch (e) { if (i === times - 1) throw e; }
  }
  throw new Error('Unreachable');
}

Samtidig feilhåndtering

Håndter feil når du kjører samtidige asynkrone operasjoner.

const [userResult, postsResult] = await Promise.allSettled([
  getUser(id).then(u => ({ ok: true, value: u })).catch(e => ({ ok: false, error: e })),
  getPosts(id).then(p => ({ ok: true, value: p })).catch(e => ({ ok: false, error: e })),
]);

Feilvidereføring i AsyncQueue

Feil i asynkrone iteratorer videreføres riktig med for-await.

async function* generate() {
  yield await fetchA();
  yield await fetchB(); // error here stops the loop
}
for await (const item of generate()) { process(item); }

Typet feil-middleware i Next.js

Bruk typede error boundaries i serverhandlinger.

'use server';
async function createUser(data: CreateUserDto): Promise<Result<User>> {
  return safeGet(() => db.user.create({ data }));
}

Kort kontroll

Hva skjer hvis du ikke fanger opp en avvist Promise i en async/await-funksjon?

Besvar den i den interaktive leksjonen

Oppsummering

Feilhåndtering i asynkron TypeScript-kode: Du har lært de viktigste konseptene i dette emnet og hvordan du bruker dem i virkelige TypeScript-prosjekter.

Gratis å komme i gang

Lær deg TypeScript med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 101
Leksjoner: 352

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Feilhåndtering i asynkron TypeScript-kode» gratis?

Ja – hele teksten i «Feilhåndtering i asynkron TypeScript-kode» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av TypeScript Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Feilhåndtering i asynkron TypeScript-kode»?

Håndter asynkrone feil med typede omslag og verktøyfunksjoner. Du øver på TypeScript Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med TypeScript Academy?

Ingen tidligere erfaring er nødvendig. TypeScript Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Feilhåndtering i asynkron TypeScript-kode»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne TypeScript Academy-leksjonen?

Ja. Alle TypeScript Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Typede feilklasser og -hierarkier
Resultat-mønsteret: Ok og Err
Snevre inn fangede feil (unknown kontra Error)
Feilhåndtering i asynkron TypeScript-kode

← Tilbake til TypeScript Academy