0Pricing
TypeScript Academy · Aula

Padrões de concorrência (all/settled/race) e tipos

Modele a concorrência com Promise.all / allSettled / race, entenda os tipos de resultado e crie auxiliares seguros.

Padrões de concorrência (all/settled/race) e tipos é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 3 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 3 aulas no total.

Introdução

Objetivo: executar tarefas simultaneamente com Promise.all, lidar com resultados mistos usando allSettled e usar race para tempos limite e alternativas. Aprenda os tipos retornados por cada um.

all: tipos de tupla

Promise.all com uma tupla preserva os tipos e a ordem dos elementos; cada elemento é aguardado até seu 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: mapa simultâneo

Inicie várias tarefas primeiro e depois use await para aguardá-las juntas. Promise.all produz string[] neste caso.

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

Tipagem de allSettled

allSettled nunca rejeita; ele resolve para uma matriz de objetos de resultado resolvidos ou rejeitados, que você pode restringir por meio de 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 + tempo limite

race resolve ou rejeita com a primeira Promise concluída. Combine-a com um tempo limite para limitar a latência.

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

Dicas e escolhas

Dicas:

  • all: coleta de resultados com falha rápida.
  • allSettled: coleta sucessos e erros sem lançar exceções.
  • race: tempos limite e alternativas; seja explícito sobre os tipos dos elementos.

Verificação da tipagem de Promise.all

Verificação rápida: qual afirmação sobre a tipagem de Promise.all é TRUE?

Recapitulação

Recapitulação: use all para paralelismo tipado, allSettled para inspecionar todos os resultados e race para tempos limite; conheça as estruturas retornadas por cada API.

Perguntas Frequentes

A aula “Padrões de concorrência (all/settled/race) e tipos” é grátis?

Sim — o texto completo de “Padrões de concorrência (all/settled/race) e tipos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 3 aulas no total.

O que vou aprender em “Padrões de concorrência (all/settled/race) e tipos”?

Modele a concorrência com Promise.all / allSettled / race, entenda os tipos de resultado e crie auxiliares seguros. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 3.

Quanto tempo leva a aula “Padrões de concorrência (all/settled/race) e tipos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Promise , tipagem de async/await
  2. Tipagem de erros (unknown), redução no catch
  3. Padrões de concorrência (all/settled/race) e tipos
← Voltar para TypeScript Academy