Por si alguien más tenía la duda.
"resolve" y "reject" no son palabras reservadas (pero sí comúnmente usadas en la sintaxis de una promesa. Se puede usar cualquier nombre como:
new Promise((simon, nel ) => (true) ? simon() : nel())
Cuando trabajas con varias promesas a la vez y necesitas saber el resultado de todas (sin importar si fallaron o se cumplieron), Promise.allSettled se vuelve tu mejor aliado. Esta funcionalidad de ECMAScript 11 te permite ejecutar un grupo de promesas y obtener una respuesta completa con el estado de cada una, ideal para desarrolladores que ya dominan los fundamentos de promesas en JavaScript.
¿Qué aporta Promise.allSettled frente a otras versiones?
Cada versión del estándar ECMAScript suele mejorar funcionalidades que antes fueron novedad. Y aquí viene lo interesante: este método no reemplaza a las promesas, las potencia.
¿Qué hace Promise.allSettled? Ejecuta un arreglo de promesas y devuelve un array con el estado final de cada una, ya sea fulfilled (cumplida) o rejected (rechazada), sin detenerse cuando una falla.
Esa es la diferencia clave con Promise.all, que se interrumpe ante el primer rechazo. Con allSettled siempre tienes el panorama completo.
¿Cómo se construyen las promesas para el ejemplo?
Para verlo en acción, dentro de la carpeta de ECMAScript 11 creas un archivo llamado 03-promiseAllSettled.js. La idea es generar tres promesas distintas y combinarlas.
La estructura básica de cada promesa usa una arrow function anónima con return implícito y recibe los parámetros resolve y reject:
reject('reject') para simular un fallo.resolve('resolve') para una respuesta exitosa.resolve('resolve2') con otro valor cumplido.Un detalle importante que se menciona alrededor del [3:10]: aunque solo uses reject o resolve, debes declarar ambos parámetros en la función anónima. Si los omites, no podrás invocar el rechazo correctamente.
js const promiseOne = new Promise((resolve, reject) => reject('reject')); const promiseTwo = new Promise((resolve, reject) => resolve('resolve')); const promiseThree = new Promise((resolve, reject) => resolve('resolve2'));
¿Cómo ejecutar Promise.allSettled con varias promesas?
Una vez tienes las tres promesas, las pasas dentro de un arreglo al método y encadenas un then para capturar la respuesta. Como allSettled también devuelve una promesa, este patrón te resulta familiar.
js Promise.allSettled([promiseOne, promiseTwo, promiseThree]) .then(response => console.log(response));
Al ejecutar el archivo, la consola te devuelve un arreglo con un objeto por cada promesa.
¿Qué información devuelve Promise.allSettled en consola?
Cada objeto del arreglo contiene un campo status y, dependiendo del resultado, un reason o un value. Esa estructura es la que te permite tomar decisiones después.
reason con el motivo del fallo. Aquí podrías inyectar errores personalizados según tu lógica de negocio.value, que contiene el recurso o dato que devolvió la promesa cumplida.¿Cuándo conviene usar Promise.allSettled en lugar de Promise.all? Cuando necesitas conocer el desenlace de todas las promesas aunque algunas fallen, por ejemplo al consultar varias APIs y querer registrar tanto las exitosas como las caídas.
Con esa información en mano, puedes continuar el flujo, mostrar mensajes específicos al usuario o reintentar las promesas rechazadas. Cada elemento del arreglo cumplirá un objetivo claro según el modelo de negocio de la aplicación o el recurso que estés construyendo.
¿Qué habilidades y conceptos refuerzas con este ejercicio?
Más allá de la sintaxis, hay nociones técnicas que vale la pena tener bien afinadas para sacarle provecho al método.
allSettled reporta sin filtrar.new Promise.Dominar estos puntos te prepara para diseñar flujos asíncronos resilientes, donde un fallo aislado no bloquea la información que sí lograste obtener.
¿Ya probaste reemplazar Promise.all por Promise.allSettled en alguno de tus proyectos? Cuéntame en los comentarios cómo cambió tu manejo de errores.
Cuando trabajas con varias promesas a la vez y necesitas saber el resultado de todas (sin importar si fallaron o se cumplieron), Promise.allSettled se vuelve tu mejor aliado. Esta funcionalidad de ECMAScript 11 te permite ejecutar un grupo de promesas y obtener una respuesta completa con el estado de cada una, ideal para desarrolladores que ya dominan los fundamentos de promesas en JavaScript.
Cada versión del estándar ECMAScript suele mejorar funcionalidades que antes fueron novedad. Y aquí viene lo interesante: este método no reemplaza a las promesas, las potencia.
¿Qué hace Promise.allSettled? Ejecuta un arreglo de promesas y devuelve un array con el estado final de cada una, ya sea fulfilled (cumplida) o rejected (rechazada), sin detenerse cuando una falla.
Esa es la diferencia clave con Promise.all, que se interrumpe ante el primer rechazo. Con allSettled siempre tienes el panorama completo.
Para verlo en acción, dentro de la carpeta de ECMAScript 11 creas un archivo llamado 03-promiseAllSettled.js. La idea es generar tres promesas distintas y combinarlas.
La estructura básica de cada promesa usa una arrow function anónima con return implícito y recibe los parámetros resolve y reject:
reject('reject') para simular un fallo.resolve('resolve') para una respuesta exitosa.resolve('resolve2') con otro valor cumplido.Un detalle importante que se menciona alrededor del [3:10]: aunque solo uses reject o resolve, debes declarar ambos parámetros en la función anónima. Si los omites, no podrás invocar el rechazo correctamente.
js const promiseOne = new Promise((resolve, reject) => reject('reject')); const promiseTwo = new Promise((resolve, reject) => resolve('resolve')); const promiseThree = new Promise((resolve, reject) => resolve('resolve2'));
Una vez tienes las tres promesas, las pasas dentro de un arreglo al método y encadenas un then para capturar la respuesta. Como allSettled también devuelve una promesa, este patrón te resulta familiar.
js Promise.allSettled([promiseOne, promiseTwo, promiseThree]) .then(response => console.log(response));
Al ejecutar el archivo, la consola te devuelve un arreglo con un objeto por cada promesa.
Cada objeto del arreglo contiene un campo status y, dependiendo del resultado, un reason o un value. Esa estructura es la que te permite tomar decisiones después.
reason con el motivo del fallo. Aquí podrías inyectar errores personalizados según tu lógica de negocio.value, que contiene el recurso o dato que devolvió la promesa cumplida.¿Cuándo conviene usar Promise.allSettled en lugar de Promise.all? Cuando necesitas conocer el desenlace de todas las promesas aunque algunas fallen, por ejemplo al consultar varias APIs y querer registrar tanto las exitosas como las caídas.
Con esa información en mano, puedes continuar el flujo, mostrar mensajes específicos al usuario o reintentar las promesas rechazadas. Cada elemento del arreglo cumplirá un objetivo claro según el modelo de negocio de la aplicación o el recurso que estés construyendo.
Más allá de la sintaxis, hay nociones técnicas que vale la pena tener bien afinadas para sacarle provecho al método.
allSettled reporta sin filtrar.new Promise.Dominar estos puntos te prepara para diseñar flujos asíncronos resilientes, donde un fallo aislado no bloquea la información que sí lograste obtener.
¿Ya probaste reemplazar Promise.all por Promise.allSettled en alguno de tus proyectos? Cuéntame en los comentarios cómo cambió tu manejo de errores.
Por si alguien más tenía la duda.
"resolve" y "reject" no son palabras reservadas (pero sí comúnmente usadas en la sintaxis de una promesa. Se puede usar cualquier nombre como:
new Promise((simon, nel ) => (true) ? simon() : nel())
Tambien existe
Promise.all()
El método Promise.all(iterable) devuelve una promesa que termina correctamente cuando todas las promesas en el argumento iterable han sido concluídas con éxito, o bien rechaza la petición con el motivo pasado por la primera promesa que es rechazada. MDN (https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Promise/all)
La diferencia con
Promise.allSettled()
Ejecuta todas las promesas sin importar si son rechazadas o no.
Hola Chic@s
**ES11: **
const promise1 = new Promise((resolve, reject) => reject("reject"));
const promise2 = new Promise((resolve, reject) => resolve("resolve"));
const promise3 = new Promise((resolve, reject) => resolve("resolve2"));
Promise.allSettled([promise1, promise2, promise3])
.then(response => console.log(response));
El método Promise.allSettled() devuelve una promesa que se cumple después de que todas las promesas dadas se hayan cumplido o rechazado, con una matriz de objetos que describen el resultado de cada promesa.
Por lo general, se usa cuando tiene varias tareas asincrónicas que no dependen unas de otras para completarse correctamente, o si siempre desea saber el resultado de cada promesa.
En comparación, la Promesa devuelta por Promise.all() puede ser más apropiada si las tareas dependen unas de otras/si desea rechazar inmediatamente cualquiera de ellas
Es dificil entender estos conceptos sin un contexto, lastimosamente hay que complementar estas clases con videos de youtube donde si explican los conceptos dando ejemplos practicos
Si no les quedo claro, aqui les dejo un video que lo explica. Duración aproximada 1min https://youtube.com/shorts/0BeOn_WSaN0?feature=share
si desean ver la información de una manera distinta a la del profe podemos utilizar console.table, la cual nos dará la información mas organizada, mostrándonos igual el resultado de la promesa, la razón, y el valor de las que fueron resueltas, espero les sirva, (no es mucho pero es trabajo honesto XD)

Todo quedó más claro leyendo la explicación que está en la sección de recursos
Mi código para este curso.
/*El método Promise.all sirve para manejar varias promesas al mismo tiempo. Recibe como argumento un
array de promesas. Promise.all() se resolverá, si y solo si todas las promesas fueron resueltas.
Si al menos una promesa es rechazada, Promise.all será rechazada. */
{
const promise1 = new Promise((resolve, reject) => reject("Rechazada"));
const promise2 = new Promise((resolve, reject) => resolve("Resuelta 2"));
const promise3 = new Promise((resolve, reject) => resolve("Resuelta 3"));
Promise.all([promise1, promise2, promise3])
.then(respuesta => console.log(respuesta))
.catch(error => console.log(error));
// Sí todas las promesas se cumplen, se ejecuta el metodo then() y el parametro respuesta es un array:
['resuelta 1', 'Resuelta 2', 'Resuelta 3'];
//Sí al menos una es rechazada, se ejecuta el metodo catch y el parametro error es un string
"Rechazada";
}
/*Promise.allSettled() permite manejar varias promesas, que devolverá un array de objetos con el
estado y el valor de cada promesa, haya sido resuelta o rechazada. */
{
const promesa1 = Promise.reject("Ups promesa 1 falló");
const promesa2 = Promise.resolve("Promesa 2 sí cumplió");
const promesa3 = Promise.reject("Ups promesa 3 falló");
Promise.allSettled([promesa1, promesa2, promesa3])
.then(respuesta => console.log(respuesta));
//El resultado, se ejecuta el metodo then() y el parametro respuesta sería este array:
[
{ status: 'rejected', reason: 'Ups promesa 1 falló' },
{ status: 'fulfilled', value: 'Promesa 2 sí cumplió' },
{ status: 'rejected', reason: 'Ups promesa 3 falló' }
];
}
28/35 ES11: Promise.allSettled Cuando necesitas manejar varias promesas al mismo tiempo y obtener sus resultados, puede utilizar los métodos Promise.all y Promise.allSettled
Promise.all toma un array de promesas como argumento y se resolverá solo si todas las promesas en el array son resueltas. Si al menos una primesa es rechazada, Promise.all se rechazará. Por ejemplo:
Promise.all([
fetch('https://api.example.com/data1'),
fetch('https://api.example.com/data2'),
fetch('https://api.example.com/data3')
]).then(respuesta => {
console.log(respuesta[0]); // respuesta de la primera promesa
console.log(respuesta[1]); // respuesta de la segunda promesa
console.log(respuesta[2]); // respuesta de la tercera promesa
}).catch(error => {
console.log(error); // si al menos una promesa fue rechazada
});
Por otro lado, Promise.allSettled toma un array de promesas como argumento y devolverá un array de objetos que contiene el estado y el valor de cada promesa, independientemente de si fue resuelta o rechazada. Por ejemplo:
const promesa1 = Promise.reject("Ups promesa 1 falló");
const promesa2 = Promise.resolve("Promesa 2");
const promesa3 = Promise.reject("Ups promesa 3 falló");
Promise.allSettled([promesa1, promesa2, promesa3])
.then(respuesta => {
console.log(respuesta[0]); // estado y razón de la promesa 1
console.log(respuesta[1]); // estado y valor de la promesa 2
console.log(respuesta[2]); // estado y razón de la promesa 3
});