Saltar al contenido
Asincronía

Combinadores de promesas

Lección 5 de 910 min4 ejercicios

Muchas veces no esperas una sola cosa, sino varias: los datos de tres secciones de un panel, la respuesta más rápida entre dos servidores, un pedido con un límite de tiempo. Los combinadores son funciones que reciben varias promesas y devuelven una sola, con distintas reglas para decidir cuándo y cómo se resuelve.

Para los ejemplos, una ayuda: una promesa que tarda ms y se cumple, o se rechaza, con un valor.

const tras = (ms, valor, falla = false) =>
  new Promise((ok, mal) => setTimeout(() => (falla ? mal(new Error(valor)) : ok(valor)), ms));

console.log(await tras(50, "hola"));

Los cuatro combinadores

Combinador Se cumple cuando… Se rechaza cuando…
Promise.all todas se cumplen (con un array de valores, en orden) alguna se rechaza (enseguida)
Promise.allSettled todas terminan, bien o mal (nunca se rechaza) —
Promise.race la primera que termine se cumple la primera que termine se rechaza
Promise.any (ES2021) la primera se cumple todas se rechazan (AggregateError)
const tras = (ms, valor, falla = false) =>
  new Promise((ok, mal) => setTimeout(() => (falla ? mal(new Error(valor)) : ok(valor)), ms));

// all: todo o nada, en paralelo
const [perfil, amigos] = await Promise.all([tras(50, "perfil"), tras(30, "amigos")]);
console.log(perfil, amigos);

// allSettled: el estado de cada una
const estados = await Promise.allSettled([tras(10, "ok"), tras(10, "caído", true)]);
console.log(estados.map((e) => e.status === "fulfilled" ? e.value : e.reason.message));

// race: la primera que termine, bien o mal
console.log(await Promise.race([tras(40, "servidor A"), tras(20, "servidor B")]));

// any: la primera que se cumpla
console.log(await Promise.any([tras(10, "falla", true), tras(30, "espejo")]));

Cuándo usar cada uno:

  • all: necesitas todos los resultados para seguir, y si uno falla no tiene sentido continuar.
  • allSettled: quieres mostrar lo que funcionó y avisar de lo que falló, por separado.
  • race: un límite de tiempo (compitiendo contra un temporizador que rechaza).
  • any: varias fuentes equivalentes, te sirve cualquiera que responda.
try {
  await Promise.any([Promise.reject(new Error("A")), Promise.reject(new Error("B"))]);
} catch (e) {
  console.log(e.name, e.errors.map((x) => x.message));
}

Promise.withResolvers (ES2024)

A veces la promesa se crea en un lugar y se cumple en otro, lejos: en un evento, en un callback que llega después. withResolvers crea la promesa y te da sus funciones por separado:

const { promise, resolve, reject } = Promise.withResolvers();

// …en otra parte del programa, cuando algo ocurre:
setTimeout(() => resolve("el usuario confirmó"), 50);

console.log(await promise);

Antes había que sacar resolve del new Promise a una variable de afuera.

Promise.try (ES2025)

Promise.try(fn) ejecuta fn y devuelve siempre una promesa: si fn devuelve un valor, la cumple; si lanza un error, aunque sea al momento, la rechaza.

function leerConfig(texto) {
  return JSON.parse(texto);  // puede lanzar al momento
}

Promise.try(() => leerConfig("{malo"))
  .then((c) => console.log(c))
  .catch((e) => console.log("atrapado:", e.name));

Sin Promise.try, el error síncrono de JSON.parse se escaparía antes de que existiera la cadena, y el catch no lo vería.

Resumen

  • all: todas o el primer error. allSettled: el estado de cada una.
  • race: la primera que termine. any: la primera que se cumpla, o AggregateError.
  • Promise.withResolvers() (ES2024) separa la promesa de sus funciones resolve y reject.
  • Promise.try(fn) (ES2025) convierte también los errores síncronos en rechazos.
  • Los combinadores no cancelan: solo deciden qué resultado te importa.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Varias promesas a la vez

Elige una respuesta en cada pregunta.

  1. ¿Qué hace Promise.all si una de las promesas se rechaza?

  2. ¿Qué diferencia hay entre race y any (ES2021)?

  3. ¿Para qué sirve Promise.withResolvers() (ES2024)?

  4. ¿Qué ventaja tiene Promise.try(fn) (ES2025)?

Ordena la salida: Quién gana

Los cuatro combinadores, con promesas que tardan distinto. Ordena lo que aparecería en la consola.

const tras = (ms, valor, falla = false) =>  new Promise((ok, mal) => setTimeout(() => (falla ? mal(new Error(valor)) : ok(valor)), ms)); const r1 = await Promise.all([tras(30, "a"), tras(10, "b")]);console.log("all:", r1.join(",")); const r2 = await Promise.race([tras(30, "lento"), tras(10, "rápido")]);console.log("race:", r2); const r3 = await Promise.any([tras(10, "x", true), tras(20, "y")]);console.log("any:", r3); const r4 = await Promise.allSettled([tras(10, "ok"), tras(10, "no", true)]);console.log("allSettled:", r4.map((r) => r.status).join(","));

Consola, de arriba abajo

  1. allSettled: fulfilled,rejected
  2. race: rápido
  3. all: a,b
  4. any: y

Detective: Todo o nada

Una sección del panel falla y no se ve ninguna. Encuentra la línea y elige el combinador correcto.

Consola

panel.js:3
    ? Promise.reject(new Error("servicio de fotos caído"))
                     ^

Error: servicio de fotos caído

Paso 1: toca la línea de código que causa el error.

Laboratorio: Un límite de tiempo

Escribe conLimite(promesa, ms) con Promise.race.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime a tiempo y tiempo agotado (pendiente)
  • Se rechaza a tiempo, sin esperar a la promesa lenta (pendiente)
  • Usa Promise.race (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.