0Pricing
TypeScript Academy · Lección

Patrones de concurrencia (all/settled/race) y tipos

Modele la concurrencia con Promise.all / allSettled / race, comprenda sus tipos de resultado y cree helpers seguros.

Patrones de concurrencia (all/settled/race) y tipos es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 3 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 3 lecciones en total.

Introducción

Objetivo: ejecutar tareas de forma concurrente con Promise.all, gestionar resultados mixtos mediante allSettled y usar race para tiempos de espera agotados y alternativas. Aprenda los tipos que devuelve cada uno.

all: tipos de tupla

Promise.all con una tupla conserva los tipos y el orden de los elementos; cada elemento se espera hasta obtener su 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 concurrente

Inicie primero varias tareas y, después, espérelas juntas con await. Aquí, Promise.all produce 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));

Tipado de allSettled

allSettled nunca se rechaza; se resuelve en un array de objetos de resultado fulfilled o rejected cuyo tipo puede acotarse mediante 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 + tiempo de espera

race se resuelve o se rechaza con la primera promesa que se establezca. Combínela con un tiempo de espera para limitar la latencia.

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

Consejos y opciones

Consejos:

  • all: recopilación de resultados con fallo rápido.
  • allSettled: recopile éxitos y errores sin lanzar excepciones.
  • race: tiempos de espera y alternativas; especifique los tipos de los elementos de forma explícita.

Comprobación del tipado de Promise.all

Comprobación rápida: ¿Qué afirmación sobre el tipado de Promise.all es VERDADERA?

Resumen

Resumen: use all para el paralelismo con tipos, allSettled para inspeccionar todos los resultados y race para los tiempos de espera; conozca las estructuras que devuelve cada API.

Preguntas frecuentes

¿La lección «Patrones de concurrencia (all/settled/race) y tipos» es gratis?

Sí — el texto completo de «Patrones de concurrencia (all/settled/race) y tipos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 3 lecciones en total.

¿Qué aprenderé en «Patrones de concurrencia (all/settled/race) y tipos»?

Modele la concurrencia con Promise.all / allSettled / race, comprenda sus tipos de resultado y cree helpers seguros. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 3.

¿Cuánto tiempo toma la lección «Patrones de concurrencia (all/settled/race) y tipos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Promise y tipado de async/await
  2. Tipado de errores (unknown) y reducción en catch
  3. Patrones de concurrencia (all/settled/race) y tipos
← Volver a TypeScript Academy