0Pricing
TypeScript Academy · Lezione

Tipi dei pattern di concorrenza (all/settled/race)

Modelli la concorrenza con Promise.all / allSettled / race, comprenda i relativi tipi risultato e crei helper sicuri.

Tipi dei pattern di concorrenza (all/settled/race) è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 3 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 3 lezioni in totale.

Introduzione

Obiettivo: eseguire attività in concorrenza con Promise.all, gestire risultati misti tramite allSettled e usare race per timeout e fallback. Imparerà i tipi restituiti da ciascuna funzione.

all: tipi delle tuple

Promise.all con una tupla preserva i tipi e l’ordine degli elementi; ogni elemento viene atteso fino a ottenere il relativo tipo interno.

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: map concorrente

Avvii prima più attività, poi le attenda insieme con await. Qui Promise.all restituisce 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));

Tipizzazione di allSettled

allSettled non rifiuta mai la Promise; la risolve in un array di oggetti risultato fulfilled o rejected, il cui tipo può essere ristretto tramite 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 e timeout

race si risolve o si rifiuta con la prima Promise completata. La combini con un timeout per limitare la latenza.

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

Suggerimenti e scelte

Suggerimenti:

  • all: raccolta dei risultati con interruzione al primo errore.
  • allSettled: raccolta di successi ed errori senza generare eccezioni.
  • race: timeout e fallback; specifichi esplicitamente i tipi degli elementi.

Verifica della tipizzazione di Promise.all

Verifica rapida: quale affermazione sulla tipizzazione di Promise.all è VERA?

Riepilogo

Riepilogo: usi all per il parallelismo tipizzato, allSettled per esaminare tutti i risultati e race per i timeout; conosca le strutture restituite da ciascuna API.

Domande Frequenti

La lezione «Tipi dei pattern di concorrenza (all/settled/race)» è gratuita?

Sì — il testo completo di «Tipi dei pattern di concorrenza (all/settled/race)» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 3 lezioni in totale.

Cosa imparerò in «Tipi dei pattern di concorrenza (all/settled/race)»?

Modelli la concorrenza con Promise.all / allSettled / race, comprenda i relativi tipi risultato e crei helper sicuri. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 3.

Quanto tempo richiede la lezione «Tipi dei pattern di concorrenza (all/settled/race)»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?

Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Promise , tipizzazione di async/await
  2. Tipizzazione degli errori (unknown), restrizione nei blocchi catch
  3. Tipi dei pattern di concorrenza (all/settled/race)
← Torna a TypeScript Academy