¿En qué se diferencia el método Promise.all() del método Promise.allSettled() en JavaScript?

En este artículo, primero comprenderemos brevemente los métodos Promise.all() y Promise.allSettled() y luego intentaremos visualizar en qué se diferencian entre sí a través de algunos ejemplos teóricos y de codificación.

Los métodos Promise.all() y Promise.allSettled() son los métodos de un objeto Promise (que es además un objeto de JavaScript que se usa para manejar todas las operaciones asincrónicas) que se usan para manejar múltiples resultados de promesas simultáneamente. La entrada de ambos métodos es una array que contiene promesas que además contienen algunos datos dentro de ellas.

Veamos ahora las sintaxis de estos dos métodos que se utilizan para declararlos o instanciarlos.

Sintaxis para el método Promise.all(): La siguiente sintaxis podría usarse para declarar este método.

Promise.all([promise_1 , promise_2,  ...]).then(
    // do something...
)

Sintaxis para el método Promise.allSettled() : La siguiente sintaxis podría usarse para declarar este método.

Promise.allSettled([promise_1 , promise_2,  ...]).then(
    // do something...
)

Ahora, después de analizar sus sintaxis, es hora de analizar el hecho de en qué se diferencian realmente entre sí.

¿Cómo se diferencian entre sí?

Los siguientes son algunos de los puntos más importantes que nos ayudarán a comprender su diferencia (y eso también con la ayuda de algunos ejemplos de codificación): –

1. En cuanto al rechazo de promesas:

• El método Promise.all() se rechaza a sí mismo si se rechaza alguna de las entradas de promesa pasadas dentro de una array. Es decir, este método solo se ejecutará si y solo si todas las promesas se cumplen o resuelven con éxito, de lo contrario, en la salida, generaría un mensaje de error.
• El método Promise.allSettled() no se rechazará a sí mismo si se rechaza alguna de las entradas de promesa pasadas dentro de una array. Es decir, este método, independientemente de cualquier promesa, también estará en estado rechazado.

2. En términos de sus productos:

• El método Promise.all() devuelve una array como salida que contiene datos de promesa dentro de varios índices.
• El método Promise.allSettled() devuelve una array de objetos y cada uno de estos objetos contiene además dos propiedades, estado y valor adicionales.

Veamos ahora algunos de los ejemplos de codificación mencionados a continuación para comprender mejor los hechos ilustrados anteriormente:

Ejemplo 1: en este ejemplo, crearemos dos promesas que se resuelven con éxito, y luego las pasaremos dentro de estos dos métodos y visualizaremos su resultado.

<script>
    let first_promise = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve("Resolved First after 1 second");
        }, 1000);
    });
  
    let second_promise = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve("Resolved First after 2 seconds");
        }, 2000);
    });
  
    try {
        let result_1 = Promise.all(
            [first_promise, second_promise]);
  
        result_1.then((data) => console.log(data));
  
        let result_2 = Promise.allSettled(
            [first_promise, second_promise]);
          
        result_2.then((data) => console.log(data));
    } catch (error) {
        console.log(error);
    }
</script>

Producción:

[ ‘Resuelto primero después de 1 segundo’, ‘Resuelto primero después de 2 segundos’ ]
[
  { status: ‘cumplido’, value: ‘Resuelto primero después de 1 segundo’ },
  { status: ‘cumplido’, value: ‘Resuelto primero después de 2 segundos’ }
]

Ejemplo 2: En este ejemplo, pasaremos una promesa rechazada en ambos métodos y luego visualizaremos sus resultados.

<script>
    let rejected_promise = new Promise((resolve, 
        reject) => reject("Rejected Promise...."));
  
    let first_promise = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve("Resolved First after 1 second");
        }, 1000);
    });
  
    let second_promise = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve("Resolved First after 2 seconds");
        }, 2000);
    });
  
    try {
        let result_1 = Promise.all([rejected_promise, 
            first_promise, second_promise]);
  
        result_1.then((data) => console.log(data));
  
        let result_2 = Promise.allSettled([
            rejected_promise,
            first_promise,
            second_promise,
        ]);
          
        result_2.then((data) => console.log(data));
    } catch (error) {
        console.log(error);
    }
</script>

Producción:

(Node: 10372) UnhandledPromiseRejectionWarning: Promesa rechazada….
(Use `node –trace-warnings…` para mostrar dónde se creó la advertencia)
(node:10372) UnhandledPromiseRejectionWarning: Rechazo de promesa no manejado. 
Este error se originó al lanzar dentro de una función asíncrona sin un bloque catch
 o al rechazar una promesa que no se manejó con .catch(). Para finalizar el proceso del Node
 en caso de rechazo de promesas no controladas, use el indicador de la CLI `–unhandled-rejections=strict`; 
 consulte https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode). (ID de rechazo: 2)
(Node: 10372) [DEP0018] DeprecationWarning: los rechazos de promesa no controlados están en desuso. 
En el futuro, los rechazos de promesas que no se manejen terminarán el proceso de Node.js 
con un código de salida distinto de cero.
[
  { estado: ‘rechazado’, motivo: ‘Promesa rechazada…’ },
  { estado: ‘cumplido’, valor: ‘Resuelto primero después de 1 segundo’ },
  { estado: ‘cumplido’, valor: ‘Resuelto primero después de 2 segundos’ }
]