Promise.allSettled en JavaScript: Manejo Completo de Promesas

El método Promise.allSettled en permite ejecutar múltiples promesas y recibir un reporte detallado del estado de cada una, independientemente de si se resolvieron o rechazaron. A diferencia de Promise.all, que se detiene si alguna de las promesas falla, Promise.allSettled espera a que todas las promesas finalicen y devuelve un array con el estado y resultado de cada una.

¿Qué es Promise.allSettled y Cuándo Usarlo?

Este método es útil cuando necesitas manejar múltiples operaciones asíncronas en paralelo y procesar los resultados, incluso si algunas de ellas fallan. Este método es ideal en situaciones donde deseas obtener un resumen de todas las operaciones sin detener el flujo, lo cual es especialmente útil en casos de consultas múltiples, análisis de datos o procesos de respaldo.

sintaxis básica:

Promise.allSettled([promesa1, promesa2, promesa3])
  .then(resultados => {
    // Manejar el array de resultados aquí
  });

La sintaxis básica de Promise.allSettled es similar a la de otros métodos de promesas. Toma un array de promesas y devuelve una nueva promesa que se resuelve con un array de objetos, cada uno con las propiedades status y value o reason.

Casos Comunes de Uso

• Recopilación de datos de múltiples fuentes, donde algunas pueden fallar sin afectar el resultado final.
• Informes de estado detallados sobre el éxito o fracaso de múltiples operaciones.
• Procesamiento de lotes de tareas donde cada resultado se maneja individualmente.

Ejemplo Básico de Uso de Promise.allSettled

Supongamos que tienes tres promesas, dos de las cuales se resuelven y una falla. Promise.allSettled devuelve el estado y el valor o razón de cada una.

let promesa1 = Promise.resolve("Promesa 1 completada");
let promesa2 = Promise.reject("Error en Promesa 2");
let promesa3 = Promise.resolve("Promesa 3 completada");

Promise.allSettled([promesa1, promesa2, promesa3])
  .then(resultados => {
    resultados.forEach((resultado, indice) => {
      if (resultado.status === "fulfilled") {
        console.log(`Promesa ${indice + 1} resultó con éxito: ${resultado.value}`);
      } else {
        console.log(`Promesa ${indice + 1} falló: ${resultado.reason}`);
      }
    });
  });

"Promesa 1 resultó con éxito: Promesa 1 completada"
"Promesa 2 falló: Error en Promesa 2"
"Promesa 3 resultó con éxito: Promesa 3 completada"

Promise.allSettled procesa todas las promesas y muestra un resumen de su estado y resultado sin detenerse en la promesa fallida.

Procesamiento de Resultados en Promise.allSettled

El array de resultados de Promise.allSettled contiene un objeto para cada promesa con las propiedades:

• status: Indica si la promesa fue fulfilled o rejected.
• value: Presente si la promesa se resolvió, contiene el resultado.
• reason: Presente si la promesa fue rechazada, contiene el motivo del error.

Ejemplo de Análisis de Resultados

async function procesarResultados(promesas) {
  const resultados = await Promise.allSettled(promesas);
  const exitosas = resultados.filter(res => res.status === "fulfilled");
  const fallidas = resultados.filter(res => res.status === "rejected");

  console.log("Promesas exitosas:", exitosas.map(res => res.value));
  console.log("Promesas fallidas:", fallidas.map(res => res.reason));
}

let promesas = [
  Promise.resolve("Datos del Usuario"),
  Promise.reject("Error en el servidor"),
  Promise.resolve("Datos de la Orden")
];

procesarResultados(promesas);

Promesas exitosas: ["Datos del Usuario", "Datos de la Orden"]
Promesas fallidas: ["Error en el servidor"]

Este ejemplo organiza los resultados en exitosos y fallidos para manejarlos de manera individual.

Ventajas de Promise.allSettled sobre Otros Métodos

1. Procesamiento de Todas las Promesas: Promise.allSettled garantiza que todas las promesas terminen antes de devolver resultados, proporcionando un resumen completo.
2. Mejor Control de Errores: En lugar de rechazar todas las promesas en el primer error, permite gestionar cada error individualmente.
3. Ideal para Operaciones en Lote: Útil cuando se necesita conocer el estado de cada operación en un lote de tareas.

Consideraciones al Usar Promise.allSettled

• Manejo de Datos Complejo: Los resultados incluyen tanto valores como razones de error, lo que puede requerir más lógica para el manejo de datos.
• Mayor Uso de Recursos: Si algunas promesas son innecesarias cuando otra falla, Promise.race puede ser más eficiente en esos casos.

Conclusión

Promise.allSettled es una herramienta poderosa en JavaScript para manejar múltiples promesas de manera simultánea, obteniendo un reporte completo de sus resultados. Es especialmente útil para situaciones donde necesitas saber el estado final de cada promesa sin detener el flujo de ejecución en caso de errores.

En el próximo artículo abordaremos Promise.any en JavaScript, que devuelve la primera promesa que se resuelve con éxito, proporcionando un enfoque diferente para manejar resultados en paralelo.