如果有任何 Promise 被拒绝，如何计算 Promise.all 中的成功次数？

Question

我目前正在尝试确定是否可以执行以下操作：

async function(x) {
  ...
}

try {
  await Promise.all([function(1), function(2), function(3), ...]);
} catch (err) {
  // Count number of successful Promises resolved at the point when one is rejected
  return statistics(num_success);
}

这可能吗？我尝试在 catch 块中执行此操作的原因是，如果出现任何错误，我可以立即终止该函数。

如果可以的话，我怎样才能做到这一点？

Answer 1

如果您希望您的所有承诺在它们得到解决（履行或拒绝）之前一直运行，您可以使用Promise.allSettled 执行此操作，如Raphael PICCOLO 的评论和SrHenry's answer。

但是，为了保持 Promise.all 立即响应拒绝的行为，您需要一些额外的自定义行为。这听起来是包装 Promse.all 的一个很好的理由。

/**
 * Receives an array, like Promise.all, and runs until the first rejection.
 *
 * Unlike Promise.all, but like Promise.allSettled, this will always resolve
 * to an object; however, like Promise.all, this will resolve as soon as it
 * encounters the first rejection.
 *
 * Returns a promise that resolves to an object with these properties:
 *   success: boolean, whether Promise.all would have succeeded
 *   count: number, number of resolved Promises at the time of return
 *   results: Array, result array containing all resolved Promises/values
 *   error: any, the reject value that caused this to fail, or null
 */
function allWithProgress(arrayOfPromises) {
  const results = new Array(arrayOfPromises);
  let count = 0;
  
  /**
   * Given an input to Promise.resolve, increments results+count 
   * when complete.
   */
  function wrap(valueOrThenable, index) {
    return Promise.resolve(valueOrThenable).then(x => {
      results[index] = x;
      count++;
      return x;
    });
  }
  
  // slice(0) prevents the results array from being modified.
  // You could also add a condition check that prevents `wrap` from
  // modifying the results after it returns.
  return Promise
    .all(arrayOfPromises.map(wrap)) // or "(e, i) => wrap(e, i)"
    .then(x => ({success: true, count, results: results.slice(0), error: null}))
    .catch(e => ({success: false, count, results: results.slice(0), error: e}));
}

// Test harness below

function timeoutPromise(string, timeoutMs) {
  console.log("Promise created: " + string + " - " + timeoutMs + "ms");
  return new Promise(function(resolve, reject) {
    window.setTimeout(function() {
      console.log("Promise resolved: " + string + " - " + timeoutMs + "ms");
      resolve(string);
    }, timeoutMs);
  });
}

Promise.resolve().then(() => {
  // success
  return allWithProgress([
    timeoutPromise("s1", 1000),
    timeoutPromise("s2", 2000),
    timeoutPromise("s3", 3000),
    "not a promise"
  ]).then(console.log);
}).then(() => {
  // failure
  return allWithProgress([
    timeoutPromise("f1", 1000),
    timeoutPromise("f2", 2000)
      // rejects with a String for Stack Snippets; use an Error in real code 
      .then(() => Promise.reject("f2 failed")),
    timeoutPromise("f3", 3000),
    "not a promise"
  ]).then(console.log);
});

请注意，ES6 Promises 不能以任何标准方式取消或回滚，因此在测试用例中 f3 不会阻止完成。如果在飞行中停止这些承诺很重要，那么您需要自己编写该逻辑。

Answer 2

正如Raphael PICCOLO 所推荐的，您可以使用Promise.allSettled<T = any>(...promises: Promise<T>[])。它返回一个包含具有status 属性的对象的数组的promise，根据每个promise 的履行或拒绝，分配有“fulfilled”或“rejected”。如果 promise 已履行，value 属性将可用，如果它拒绝，reason 属性将可用。

示例代码：

//...

const promises = []; //Array with promises.
let count = 0;

Promise.allSettled(promises)
    .then(settled => {
        settled.forEach(({ status, value, reason }) => {
            if (status === 'fulfilled')
                count++;
        })
    })
    .then(() => statistics(count));

//...