0Pricing
TypeScript Academy · Lekcja

Typy wzorców współbieżności (all/settled/race)

Modelowanie współbieżności za pomocą Promise.all / allSettled / race, poznanie typów wyników i tworzenie bezpiecznych funkcji pomocniczych

Typy wzorców współbieżności (all/settled/race) to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 3 z 3. 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 3 lekcji w sumie.

Wprowadzenie

Cel: Uruchamiać zadania współbieżnie za pomocą Promise.all, obsługiwać mieszane wyniki przez allSettled oraz używać race do limitów czasu i mechanizmów awaryjnych. Poznać typy zwracane przez każdą z tych funkcji.

all: typy krotek

Promise.all użyte z krotką zachowuje typy i kolejność elementów; każdy element jest oczekiwany do uzyskania jego typu wewnętrznego.

async function one(): Promise<number> { return 1 }
async function two(): Promise<string> { return "two" }

async function runAll() {
  const [a, b] = await Promise.all([one(), two()]);
  // a: number, b: string
  console.log(a + 1, b.toUpperCase());
}

runAll();

all: współbieżne mapowanie

Najpierw uruchom wiele zadań, a następnie użyj await, aby zaczekać na nie razem. W tym przypadku Promise.all zwraca string[].

async function fetchItem(id: number): Promise<string> {
  return `item-${id}`;
}

async function getMany(ids: number[]): Promise<string[]> {
  const tasks = ids.map(id => fetchItem(id)); // start all
  return Promise.all(tasks); // await all
}

getMany([1,2,3]).then(xs => console.log(xs));

Typowanie allSettled

allSettled nigdy nie odrzuca obietnicy; rozstrzyga się tablicą obiektów wyników oznaczonych jako fulfilled lub rejected, które można zawężać na podstawie pola status.

async function mightFail(n: number): Promise<number> {
  if (n % 2 === 0) return n; else throw new Error("odd")
}

async function runSettled() {
  const results = await Promise.allSettled([mightFail(1), mightFail(2)]);
  for (const r of results) {
    if (r.status === "fulfilled") {
      // r: PromiseFulfilledResult<number>
      console.log("ok", r.value);
    } else {
      // r: PromiseRejectedResult
      console.warn("fail", r.reason);
    }
  }
}

runSettled();

race + limit czasu

race rozstrzyga się lub odrzuca wraz z pierwszą rozstrzygniętą obietnicą. Połącz je z timeoutem, aby ograniczyć czas oczekiwania.

function timeout<T>(ms: number, msg = "Timeout"): Promise<T> {
  return new Promise((_, reject) => setTimeout(() => reject(new Error(msg)), ms));
}

async function slow(): Promise<string> { return new Promise(res => setTimeout(() => res("done"), 100)); }

async function withTimeout() {
  const result = await Promise.race<Promise<string>>([
    slow(),
    timeout<string>(50, "Too slow"),
  ]);
  console.log(result);
}

withTimeout().catch(e => console.error("raced:", e.message));

Wskazówki i wybór funkcji

Wskazówki:

  • all: gromadzenie wyników z natychmiastowym przerwaniem po błędzie.
  • allSettled: zebranie sukcesów i błędów bez zgłaszania wyjątku.
  • race: limity czasu i mechanizmy awaryjne; należy jawnie określić typy elementów.

Sprawdzenie typowania Promise.all

Szybkie sprawdzenie: Które stwierdzenie dotyczące typowania Promise.all jest PRAWDZIWE?

Podsumowanie

Podsumowanie: Używaj all do typowanego wykonywania równoległego, allSettled do sprawdzania wszystkich wyników, a race do limitów czasu — poznaj kształty danych zwracanych przez każde API.

Często zadawane pytania

Czy lekcja „Typy wzorców współbieżności (all/settled/race)” jest bezpłatna?

Tak — pełny tekst „Typy wzorców współbieżności (all/settled/race)” 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 3 lekcji w sumie.

Co nauczysz się w „Typy wzorców współbieżności (all/settled/race)”?

Modelowanie współbieżności za pomocą Promise.all / allSettled / race, poznanie typów wyników i tworzenie bezpiecznych funkcji pomocniczych Ć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 3 z 3.

Ile czasu zajmuje lekcja „Typy wzorców współbieżności (all/settled/race)”?

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

  1. Promise i typowanie async/await
  2. Typowanie błędów (unknown) i zawężanie w catch
  3. Typy wzorców współbieżności (all/settled/race)
← Powrót do TypeScript Academy