TypeScript Academy · Lekcja

Obsługa błędów w asynchronicznym kodzie TypeScript

Zarządzaj błędami asynchronicznymi za pomocą typowanych opakowań i narzędzi.

Obsługa błędów w asynchronicznym kodzie TypeScript to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej TypeScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Witamy

Funkcje asynchroniczne zwiększają złożoność obsługi błędów. TypeScript zapewnia prawidłową obsługę odrzuceń Promise.

Try-catch z async/await

Umieszczaj wywołania await w try-catch, aby obsługiwać odrzucenia Promise.

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');
  }
}

Błędy Promise.all

Promise.all odrzuca wynik przy pierwszym odrzuceniu. Umieść je w try-catch.

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

Promise.allSettled

allSettled zwraca zarówno powodzenia, jak i niepowodzenia, nie zgłaszając wyjątków.

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);
});

Typowany wynik asynchroniczny

Połącz asynchroniczność ze wzorcem Result, aby jawnie obsługiwać błędy.

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 }; }
}

Nieobsłużone odrzucenia

W Node.js nasłuchuj nieobsłużonych odrzuceń, aby zapobiegać awariom.

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

Limit czasu z Promise.race

Zaimplementuj typowany wzorzec limitu czasu za pomocą 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]);
}

Wzorzec ponawiania

Zaimplementuj typowane asynchroniczne ponawianie operacji z typowanymi błędami.

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');
}

Równoczesna obsługa błędów

Obsługuj błędy podczas uruchamiania równoczesnych operacji asynchronicznych.

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 })),
]);

Propagowanie błędów w AsyncQueue

Błędy w iteratorach asynchronicznych są prawidłowo propagowane za pomocą for-await.

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

Typowany middleware błędów w Next.js

Używaj typowanych granic błędów w server actions.

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

Szybki test

Co się stanie, jeśli w funkcji async/await nie przechwycisz odrzuconego Promise?

Podsumowanie

Obsługa błędów w asynchronicznym kodzie TypeScript: poznano kluczowe koncepcje tego tematu oraz sposoby stosowania ich w rzeczywistych projektach TypeScript.

Często zadawane pytania

Czy lekcja „Obsługa błędów w asynchronicznym kodzie TypeScript” jest bezpłatna?

Tak — pełny tekst „Obsługa błędów w asynchronicznym kodzie TypeScript” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu TypeScript Academy, przejdź na CoddyKit PRO. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Obsługa błędów w asynchronicznym kodzie TypeScript”?

Zarządzaj błędami asynchronicznymi za pomocą typowanych opakowań i narzędzi. Ćwiczysz TypeScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć TypeScript Academy?

Nie wymagamy żadnego doświadczenia. TypeScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Obsługa błędów w asynchronicznym kodzie TypeScript”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji TypeScript Academy?

Tak. Każda lekcja TypeScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Typowane klasy błędów i hierarchie
Wzorzec Result: Ok i Err
Zawężanie przechwyconych błędów (unknown a Error)
Obsługa błędów w asynchronicznym kodzie TypeScript

← Powrót do TypeScript Academy