Unterschiede zwischen Promise.all() und Promise.allSettled() in JS?

Ich las die MDN‘s Handbuch auf Versprechenund ich habe diese beiden Methoden gefunden, die mir ähnlich erscheinen:

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

Beide nehmen eine wiederholbar und geben Sie ein Array zurück, das die erfüllten enthält Promises.

Also, was ist der Unterschied zwischen ihnen?

Promise.all wird so schnell wie möglich ablehnen eines der Promises im Array lehnt ab.

Promise.allSettled wird nie ablehnen – es wird einmal gelöst alle Promises im Array wurden entweder abgelehnt oder aufgelöst.

Ihre Auflösungswerte sind ebenfalls unterschiedlich. Promise.all wird in ein Array von jedem der Werte aufgelöst, in die die Promises aufgelöst werden – z [Promise.resolve(1), Promise.resolve(2)] wird sich verwandeln [1, 2]. Promise.allSettled wird dir stattdessen geben [{ 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);

Lehnt man eines der Promises ab, wird das Promise.all wird mit einem Wert der Ablehnung abgelehnt, aber Promise.allSettled wird mit einem Objekt von aufgelöst { status: 'rejected', reason: <error> } an dieser Stelle im Array.

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);

Versprechen.all: Es wird nur aufgelöst, wenn alle An ihn übergebene Versprechen (als Array) werden aufgelöst, andernfalls wird er mit dem abgelehnt Erste Zurückgewiesener Versprechungsfehler.

Alles versprochen: Dieser wird stets mit einem Array aufgelöst werden, das Informationen über aufgelöst enthält und abgelehnte Versprechungen. Sehen Sie sich folgende Eigenschaften genau an (Status, Wert, Grund ) des resultierenden Arrays.

Beispiel 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

Ausgabe :

[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

Beispiel 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));

Ausgabe :

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

Wenn Sie sicherstellen möchten, dass das Versprechen für die von Ihnen verwendete Operation vollständig aufgelöst/erfolgreich ist, müssen Sie verwenden Promise.all da es abgeschlossen ist, wenn es für jedes der Versprechen gelöst wird.

Aber wenn Sie nur alle Versprechen erfüllen möchten, unabhängig davon, ob sie gelöst oder abgelehnt wurden, dann verwenden Sie Promise.allSettled.

Beide führen Versprechen in großen Mengen aus, aber der feine Unterschied besteht in der Art und Weise, wie sie mit den Versprechen-Iterationen umgehen.

Versprechen.all : Es gibt ein Promise zurück, das aufgelöst wird, wenn alle Promises aus einem Array aufgelöst sind, und zurückgewiesen wird, wenn ein oder mehrere Promises abgelehnt werden.

Versprochen.allesErledigt : Es gibt ein Promise zurück, das aufgelöst wird, wenn alle Promises im Array erfüllt (abgelehnt oder aufgelöst) sind.

Notiz : Beide nehmen ein Iterable und geben ein Array zurück, das die erfüllten Promises enthält.