PricingLoginStart free
TypeScript Academy · Lektion

Fejlhåndtering i asynkron TypeScript-kode

Håndtér asynkrone fejl med typede wrappers og hjælpefunktioner

Lektion 4 af 413 trin

Fejlhåndtering i asynkron TypeScript-kode er en gratis TypeScript Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i TypeScript Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. TypeScript Academy-kurset indeholder 4 lektioner i alt.

Velkommen

Asynkrone funktioner gør fejlhåndtering mere kompleks. TypeScript sikrer, at du håndterer afviste Promise-værdier korrekt.

Try-catch med async/await

Omslut await-kald i try-catch for at håndtere afviste Promise-værdier.
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');
  }
}

Fejl i Promise.all

Promise.all afvises ved den første afvisning. Omslut kaldet 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 fejl uden at kaste en fejl.
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

Kombinér asynkron kode med Result-mønsteret for eksplicit fejlhå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 afvisninger

Lyt efter ubehandlede afvisninger i Node.js for at forhindre nedbrud.
process.on('unhandledRejection', (reason: unknown) => {
  console.error('Unhandled rejection:', reason);
  process.exit(1);
});

Tidsgrænse med Promise.race

Implementér et typet mønster for tidsgrænser 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]);
}

Gentagelsesmønster

Implementér typet asynkron gentagelse med typede fejl.
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 fejlhåndtering

Håndtér fejl, når du kører samtidige asynkrone operationer.
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 })),
]);

Fejlvideregivelse i AsyncQueue

Fejl i asynkrone iteratorer videresendes korrekt 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 fejl-middleware i Next.js

Brug typede fejlgrænser i serverhandlinger.
'use server';
async function createUser(data: CreateUserDto): Promise<Result<User>> {
  return safeGet(() => db.user.create({ data }));
}

Hurtigt tjek

Hvad sker der, hvis du ikke fanger en afvist Promise-værdi i en async/await-funktion?
Besvar den i den interaktive lektion

Opsummering

Fejlhåndtering i asynkron TypeScript-kode: Du har lært de vigtigste begreber i dette emne, og hvordan du anvender dem i virkelige TypeScript-projekter.
Gratis at komme i gang

Lær TypeScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
101
Lektioner
352
Start gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “Fejlhåndtering i asynkron TypeScript-kode” gratis?

Ja — hele teksten til “Fejlhåndtering i asynkron TypeScript-kode” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af TypeScript Academy-kurset, skal du opgradere til CoddyKit PRO. TypeScript Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Fejlhåndtering i asynkron TypeScript-kode”?

Håndtér asynkrone fejl med typede wrappers og hjælpefunktioner Du øver dig i TypeScript Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på TypeScript Academy?

Der kræves ingen tidligere erfaring. TypeScript Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Fejlhåndtering i asynkron TypeScript-kode”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne TypeScript Academy-lektion?

Ja. Alle TypeScript Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Typede fejlklasser og -hierarkier
  2. Result-mønstret: Ok og Err
  3. Indsnævring af indfangede fejl (unknown eller Error)
  4. Fejlhåndtering i asynkron TypeScript-kode
← Tilbage til TypeScript Academy