Combinadores de Promesas

Contenido del curso

Event Loop and Execution Model

Callbacks

Promesas

Async/Await Javascript Moderno

Casos reales de uso de asincronismo

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:009:45

Combinadores de Promesas

Curso de Asincronismo con Javascript

Clase 9 de 18

Clase 9 / 18

Recursos

Ejecutar promesas de forma secuencial funciona, pero cuando las operaciones son independientes entre sí, el rendimiento se resiente innecesariamente. Si tres promesas tardan 300, 200 y 400 milisegundos respectivamente, en secuencia el total sería 900 milisegundos. En paralelo, solo tardaría lo que dure la más lenta: 400 milisegundos. Esta diferencia es fundamental para el performance de cualquier aplicación. JavaScript ofrece cuatro combinadores de promesas que permiten coordinar múltiples operaciones asíncronas con comportamientos distintos según lo que necesites.

¿Cómo funciona Promise.all para ejecutar promesas en paralelo?

Promise.all recibe un array de promesas y devuelve una nueva promesa que se resuelve únicamente cuando todas se resuelven con éxito [0:56]. Si una sola rechaza, toda la operación rechaza. Es un enfoque de todo o nada.

En el ejemplo práctico se realizan tres peticiones a la Platzi Fake Store API para obtener productos con distintos IDs. Si todas las peticiones son exitosas, se obtiene un array con los resultados y se puede iterar con forEach para mostrar el título y precio de cada producto [1:18].

javascript Promise.all([ fetchProduct(4), fetchProduct(5), fetchProduct(6) ]) .then(products => { products.forEach(p => console.log(p.title, p.price)); }) .catch(error => console.error(error));

Pero si una sola de las promesas falla, todas fallan [2:04]. Esto es útil cuando necesitas todos los resultados para continuar: por ejemplo, cargar el ID, nombre y email de un usuario en una pantalla donde todos los datos son obligatorios.

¿Cuándo usar Promise.allSettled en lugar de Promise.all?

Promise.allSettled espera a que todas las promesas terminen sin importar si se resolvieron o rechazaron [2:30]. Devuelve un array de objetos que describen el resultado de cada una, con un campo status que indica fulfilled o rejected.

javascript Promise.allSettled([ Promise.resolve("Éxito"), Promise.reject("Falló"), Promise.resolve("Éxito también") ]).then(results => { results.forEach(r => { if (r.status === "fulfilled") console.log(r.value); else console.log("Error:", r.reason); }); });

El caso de uso ideal es cuando tienes operaciones independientes y quieres conocer el resultado de cada una sin cancelar las demás [3:15]. Un ejemplo claro: enviar notificaciones a múltiples usuarios y saber cuáles llegaron y cuáles no.

¿Qué hace Promise.race y cómo implementar timeouts?

Promise.race devuelve el resultado de la primera promesa que termine, sin importar si fue exitosa o falló [3:30]. Las demás se ignoran por completo.

javascript const rapida = new Promise(resolve => setTimeout(() => resolve("Rápida"), 100)); const lenta = new Promise(resolve => setTimeout(() => resolve("Lenta"), 500)); const mediana = new Promise(resolve => setTimeout(() => resolve("Mediana"), 300));

Promise.race([rapida, lenta, mediana]) .then(ganadora => console.log(ganadora)); // "Rápida"

Un uso práctico muy potente es implementar timeouts [4:05]. Se crea una promesa que rechaza tras cierto tiempo y se compite contra la petición real. Si la petición no responde dentro del límite, el timeout gana y se muestra el error. Al poner 100 milisegundos como límite, la API no alcanza a responder. Cambiándolo a un segundo, la petición llega a tiempo y se obtienen los datos correctamente [4:40].

¿Para qué sirve Promise.any y en qué se diferencia de race?

Promise.any devuelve la primera promesa que se resuelva exitosamente [5:05]. A diferencia de Promise.race, ignora los rechazos individuales. Solo rechaza si todas las promesas fallan, generando un AggregateError.

javascript Promise.any([ Promise.reject("Falló"), Promise.resolve("Éxito"), Promise.resolve("También éxito") ]).then(resultado => console.log(resultado)); // "Éxito"

Si todas fallan, ahí sí se produce un error completo [5:35]. El caso de uso principal es la redundancia con fallback automático: intentar la misma operación contra varios endpoints y quedarte con la primera respuesta exitosa.

¿Cuál combinador de promesas elegir según tu caso de uso?

Promise.all: necesitas todos los resultados y si uno falla, falla todo.
Promise.allSettled: quieres saber el estado individual de cada promesa, sin cancelar ninguna.
Promise.race: necesitas implementar timeouts o elegir el servidor más rápido.
Promise.any: buscas redundancia, quedándote con la primera respuesta exitosa.

Con estos cuatro combinadores se completa el toolkit de promesas: ciclo de vida, encadenamiento, manejo de errores y coordinación en paralelo [6:20]. La regla de oro es simple: si las operaciones son independientes, ejecútalas en paralelo. Si una depende de otra, mantén la secuencia. ¿Ya tienes claro cuál combinador usarías en tu próximo proyecto? Comparte tu caso de uso en los comentarios.

Resumen

¿Cómo funciona Promise.all para ejecutar promesas en paralelo?

javascript Promise.all([ fetchProduct(4), fetchProduct(5), fetchProduct(6) ]) .then(products => { products.forEach(p => console.log(p.title, p.price)); }) .catch(error => console.error(error));

¿Cuándo usar Promise.allSettled en lugar de Promise.all?

¿Qué hace Promise.race y cómo implementar timeouts?

Promise.race devuelve el resultado de la primera promesa que termine, sin importar si fue exitosa o falló [3:30]. Las demás se ignoran por completo.

Promise.race([rapida, lenta, mediana]) .then(ganadora => console.log(ganadora)); // "Rápida"

¿Para qué sirve Promise.any y en qué se diferencia de race?

javascript Promise.any([ Promise.reject("Falló"), Promise.resolve("Éxito"), Promise.resolve("También éxito") ]).then(resultado => console.log(resultado)); // "Éxito"

¿Cuál combinador de promesas elegir según tu caso de uso?

Promise.all: necesitas todos los resultados y si uno falla, falla todo.
Promise.allSettled: quieres saber el estado individual de cada promesa, sin cancelar ninguna.
Promise.race: necesitas implementar timeouts o elegir el servidor más rápido.
Promise.any: buscas redundancia, quedándote con la primera respuesta exitosa.

Event Loop and Execution Model

Quien domina el Asincronismo domina JS

Microtasks vs Macrotasks

Callbacks

Higher-Order Functions y el patrón Callback

Convenciones Error-First y Node.js

Callback Hell: La Pirámide del Destino

Promesas

El ciclo de vida de una Promesa

Consumiendo y encadenando Promesas

Manejo de errores y rechazos

Combinadores de Promesas

Async/Await Javascript Moderno

La función async y la palabra clave await

Manejo de errores con try/catch en funciones async

Patrones de ejecución: secuencial vs paralelo

Refactorizando Promise chains a async/await

Casos reales de uso de asincronismo

Presentacion Proyecto

Fetch API: cómo validar respuestas con response.ok

Archivos del proyecto

Integrar LLMs con Async y Abort Controller

integracion con LLMs

Combinadores de Promesas

Progreso del curso

Event Loop and Execution Model

Callbacks

Promesas

Async/Await Javascript Moderno

Casos reales de uso de asincronismo

Recursos

Recursos