¿Diferencias entre Promise.all() y Promise.allSettled() en JS?

estaba leyendo el MDNmanual de Promesay encontré estos dos métodos que me parecen similares:

• Promise.allSettled(iterable);
• Promise.all(iterable);

Ambos toman un iterable y devolver una matriz que contiene el cumplido Promises.

Entonces, ¿cuál es la diferencia entre ellos?

Promise.all rechazará tan pronto como una de las Promesas en la matriz rechaza.

Promise.allSettled nunca rechazará – se resolverá una vez todos Las promesas de la matriz se han rechazado o resuelto.

Sus valores de resolución también son diferentes. Promise.all se resolverá en una matriz de cada uno de los valores en los que se resuelven las Promesas, por ejemplo [Promise.resolve(1), Promise.resolve(2)] se convertirá en [1, 2]. Promise.allSettled en su lugar te dará [{ status : 'fulfilled', value: 1 }, { status : 'fulfilled', value: 2 }].

Promise.all([Promise.resolve(1), Promise.resolve(2)])
  .then(console.log);
Promise.allSettled([Promise.resolve(1), Promise.resolve(2)])
  .then(console.log);

Si una de las Promesas rechaza, el Promise.all rechazará con un valor del rechazo, pero Promise.allSettled resolverá con objeto de { status: 'rejected', reason: <error> } en ese lugar de la matriz.

Promise.all([Promise.reject(1), Promise.resolve(2)])
  .catch((err) => {
    console.log('err', err);
  });
Promise.allSettled([Promise.reject(1), Promise.resolve(2)])
  .then(console.log);

Promise.all: Se resuelve solo cuando todos las promesas que se le pasan (como una matriz) se resuelven; de lo contrario, se rechazará con el primero error de promesa rechazada.

Promise.allSettled: este lo hará siempre se resuelve con una matriz que tiene información sobre lo resuelto y promesas rechazadas. Eche un vistazo de cerca a las siguientes propiedades (estado, valor, razón ) de la matriz resultante.

Ejemplo 1:

const pms1 = Promise.resolve(1);
// setTimeout(function, milliseconds, param1, param2, ...)
const pms2 = new Promise((resolve, reject) => {
  setTimeout(resolve, 200, 2);
});
const pms3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 3);
});
const pmsAry = [pms1, pms2, pms3];

Promise.all(pmsAry)
  .then(resAry => console.log(resAry)) // resAry order is same as pmsAry order
  .catch(error => console.log(error));

/* 
 * Note here we are not writing 'catch' because Promise.allSettled ALWAYS RESOLVES
 * with array containing information about resolved or rejected promises
 */
Promise.allSettled(pmsAry)
.then(resAry => console.log(resAry)); // resAry order is same as pmsAry order

Producción :

[1, 2, 3] 
// Promise.all output ORDER doesn't depend on promise resolution time

[{ status: "fulfilled", value: 1 },
 { status: "fulfilled", value: 2 }, 
 { status: "fulfilled", value: 3 }]
// Promise.allSettled output ORDER doesn't depend on promise resolution time

Ejemplo 2:

const pms1 = Promise.resolve(1);
const pms2 = new Promise((resolve, reject) => {
  setTimeout(reject, 200, '200ms Err');
});
const pms3 = new Promise((resolve, reject) => {
  setTimeout(reject, 100, '100ms Err');
});
const pmsAry = [pms1, pms2, pms3];

Promise.all(pmsAry)
  .then(resAry => console.log(resAry))
  .catch(error => console.log(error));

Promise.allSettled(pmsAry)
  .then(resAry => console.log(resAry));

Producción :

100ms Err
/* 
 * Note: Here there are TWO promises which are getting REJECTED but output is
 * ONLY ONE (i.e the one which is getting rejected FIRST) 
 */

[{ status: "fulfilled", value: 1 },             // Note: value
 { status: "rejected", reason: "200ms Err" },   
 { status: "rejected", reason: "100ms Err" }]   // Note: reason

Cuando desee asegurarse de que la promesa se resuelva o tenga éxito en la operación que está utilizando, debe usar Promise.all ya que se completa cuando se resuelve para cada una de las promesas.

Pero cuando solo desea completar todas las promesas, independientemente de si se resuelven o rechazan, use Promise.allSettled.

Ambos ejecutan promesas a granel, pero la diferencia sutil es la forma en que manejan las iteraciones de promesa.

Promise.all : Devuelve una promesa que resuelve, cuando se resuelven todas las promesas de una matriz y se rechaza si se rechaza una o más promesas.

Promise.allSettled : Devuelve una promesa que se resuelve cuando todas las promesas de la matriz se liquidan (rechazadas o resueltas).

Nota : Ambos toman un iterable y devuelven una matriz que contiene las Promesas cumplidas.