0Pricing
TypeScript Academy · Lektion

Nebenläufigkeitsmuster (all/settled/race) und Typen

Modellieren Sie Nebenläufigkeit mit Promise.all / allSettled / race, verstehen Sie deren Ergebnistypen und erstellen Sie sichere Hilfsfunktionen.

Nebenläufigkeitsmuster (all/settled/race) und Typen ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 3 Lektionen.

Einführung

Ziel: Führen Sie Aufgaben mit Promise.all nebenläufig aus, behandeln Sie gemischte Ergebnisse über allSettled und verwenden Sie race für Timeouts und Fallbacks. Lernen Sie die Typen kennen, die die einzelnen APIs zurückgeben.

all: Tupeltypen

Promise.all mit einem Tupel bewahrt Elementtypen und Reihenfolge; jedes Element wird bis zu seinem inneren Typ aufgelöst.

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: nebenläufige Abbildung

Starten Sie zuerst mehrere Aufgaben und warten Sie dann gemeinsam mit await auf sie. Promise.all liefert hier 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));

Typisierung von allSettled

allSettled wird nie zurückgewiesen; es liefert ein Array aus erfüllten oder zurückgewiesenen Ergebnisobjekten, die Sie anhand von status eingrenzen können.

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 und Timeout

race wird mit dem zuerst abgeschlossenen Promise erfüllt oder zurückgewiesen. Kombinieren Sie es mit einem Timeout, um die Latenz zu begrenzen.

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

Tipps und Auswahl

Tipps:

  • all: Schnelles Sammeln von Ergebnissen mit Abbruch beim ersten Fehler.
  • allSettled: Erfolge und Fehler sammeln, ohne eine Exception auszulösen.
  • race: Timeouts und Fallbacks; legen Sie die Elementtypen explizit fest.

Prüfung zur Promise.all-Typisierung

Schnellprüfung: Welche Aussage zur Typisierung von Promise.all ist RICHTIG?

Zusammenfassung

Zusammenfassung: Verwenden Sie all für typisierte Parallelisierung, allSettled zur Prüfung aller Ergebnisse und race für Timeouts – kennen Sie die Strukturen, die die einzelnen APIs zurückgeben.

Häufig gestellte Fragen

Ist die Lektion „Nebenläufigkeitsmuster (all/settled/race) und Typen“ kostenlos?

Ja — der vollständige Text von „Nebenläufigkeitsmuster (all/settled/race) und Typen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Nebenläufigkeitsmuster (all/settled/race) und Typen“?

Modellieren Sie Nebenläufigkeit mit Promise.all / allSettled / race, verstehen Sie deren Ergebnistypen und erstellen Sie sichere Hilfsfunktionen. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 3.

Wie lange dauert die Lektion „Nebenläufigkeitsmuster (all/settled/race) und Typen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Promise , Typisierung von async/await
  2. Fehlertypisierung (unknown), Eingrenzung in catch
  3. Nebenläufigkeitsmuster (all/settled/race) und Typen
← Zurück zu TypeScript Academy