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, oAggregateError.Promise.withResolvers()(ES2024) separa la promesa de sus funcionesresolveyreject.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
Resuelto
Elige una respuesta en cada pregunta.
¿Qué hace
Promise.allsi una de las promesas se rechaza?¿Qué diferencia hay entre
raceyany(ES2021)?¿Para qué sirve
Promise.withResolvers()(ES2024)?¿Qué ventaja tiene
Promise.try(fn)(ES2025)?
Ordena la salida: Quién gana
Resuelto
Los cuatro combinadores, con promesas que tardan distinto. Ordena lo que aparecería en la consola.
1const tras = (ms, valor, falla = false) =>2 new Promise((ok, mal) => setTimeout(() => (falla ? mal(new Error(valor)) : ok(valor)), ms));3 4const r1 = await Promise.all([tras(30, "a"), tras(10, "b")]);5console.log("all:", r1.join(","));6 7const r2 = await Promise.race([tras(30, "lento"), tras(10, "rápido")]);8console.log("race:", r2);9 10const r3 = await Promise.any([tras(10, "x", true), tras(20, "y")]);11console.log("any:", r3);12 13const r4 = await Promise.allSettled([tras(10, "ok"), tras(10, "no", true)]);14console.log("allSettled:", r4.map((r) => r.status).join(","));Consola, de arriba abajo
- allSettled: fulfilled,rejected
- race: rápido
- all: a,b
- any: y
all respeta el orden del array, no el de llegada. race se queda con la primera que termina. any ignora la que falló y espera a la primera que se cumple. allSettled informa el estado de cada una.
Detective: Todo o nada
Resuelto
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ídoPaso 1: toca la línea de código que causa el error.
Paso 2: ¿cómo lo arreglas?
Laboratorio: Un límite de tiempo
Resuelto
Escribe conLimite(promesa, ms) con Promise.race.
$ node programa.js
Lo que debe cumplir
- Imprime
a tiempoytiempo agotado(pendiente) - Se rechaza a tiempo, sin esperar a la promesa lenta (pendiente)
- Usa
Promise.race(pendiente)
Una solución
1const esperar = (ms, valor) => new Promise((r) => setTimeout(() => r(valor), ms));2 3function conLimite(promesa, ms) {4 const reloj = new Promise((_, rechazar) =>5 setTimeout(() => rechazar(new Error("tiempo agotado")), ms)6 );7 return Promise.race([promesa, reloj]);8}9 10console.log(await conLimite(esperar(20, "a tiempo"), 100));11try {12 await conLimite(esperar(200, "tarde"), 50);13} catch (e) {14 console.log(e.message);15}race se queda con la primera que termina, se cumpla o se rechace. Ojo: la promesa lenta no se cancela, sigue su curso aunque nadie espere su resultado. Para cancelar de verdad está AbortController, dos temas más adelante.