Promise.all 和连续运行 Promise 之间的区别?

Question

假设我有一堆承诺。

const promises = [ /*...*/ ];

我希望当所有的承诺都得到解决时，会发生一些事情。以下两种方法有什么区别：

1. 使用Promise.all

   const allDonePromise = Promise.all(promises);
   

2. 连续运行承诺

   async function allPromises(promisesArray) {
   const results = [];
   for (const promise of promisesArray) {
   results.push(await promise);
   }
   return results;
   }
   const allDonePromises = allPromises(promises);
   

Promise.all只是一个内置的，它执行allPromises所做的事情，还是在引擎盖下发生了其他事情以使 Promise.all 更快。在哪里可以找到有关Promise.all内部的信息？

Answer 1

您可以在 ECMAScript 2015 语言规范的第 25.4.4.1 节中找到Promise.all规范。

你自己的实现确实在做正确的事情。区别在于细节：

上述规范在第 25.4.4.1.1.r 点指出，将在每个承诺上调用then。这些调用是同步发生的(注意：不是它们的回调(。每当任何承诺解析时，剩余的元素计数都会递减(参见步骤 2.10(。每当它达到零时，Promise.all返回的承诺就会被解析(注意：同步！

现在假设你有一个包含一百万个承诺的数组，第一个承诺需要最长的时间来解析，那么你的函数仍然需要在函数返回之前执行999999等待，而规范中的算法在第一个承诺解决之前已经处理了这些999999承诺的分辨率，并且在第一个承诺最终解决后几乎没有什么可做的。

例如，您可以在此 polyfill/promise.js 实现中看到这一点(其中计数通过递增进行(：

shaka.polyfill.Promise.all = function(others) {
var p = new shaka.polyfill.Promise();
if (!others.length) {
p.resolve_([]);
return p;
}
// The array of results must be in the same order as the array of Promises
// passed to all().  So we pre-allocate the array and keep a count of how
// many have resolved.  Only when all have resolved is the returned Promise
// itself resolved.
var count = 0;
var values = new Array(others.length);
var resolve = function(p, i, newValue) {
shaka.asserts.assert(p.state_ != shaka.polyfill.Promise.State.RESOLVED);
// If one of the Promises in the array was rejected, this Promise was
// rejected and new values are ignored.  In such a case, the values array
// and its contents continue to be alive in memory until all of the Promises
// in the array have completed.
if (p.state_ == shaka.polyfill.Promise.State.PENDING) {
values[i] = newValue;
count++;
if (count == values.length) {
p.resolve_(values);
}
}
};
var reject = p.reject_.bind(p);
for (var i = 0; i < others.length; ++i) {
if (others[i].then) {
others[i].then(resolve.bind(null, p, i), reject);
} else {
resolve(p, i, others[i]);
}
}
return p;
};

但请注意，浏览器实现不同。上面的填充只是可能的实现之一。

请注意，您的函数不是"串行运行承诺"。无论你是否对它们做某事，这些承诺都是"运行">^*：一旦你构建它们，它们就会完成它们的工作。

唯一被序列化的是你开始查看(即等待(各自承诺决议的那一刻。规范似乎暗示实现应该从一开始就侦听所有承诺的解析回调。这是你不能在循环中使用await实现的(嗯，你可以，但是你需要重复调用async函数，每个承诺一次，这不会给你带来任何好处使用await超过then，因为你需要在async函数返回的承诺上应用then(。

然后在this和参数验证方面还有其他一些(明显的(差异。值得注意的是，ECMA规范指出：

all函数要求其this值是支持Promise构造函数的参数约定的构造函数。

---

_{* 承诺并没有真正"运行"，因为承诺是对象，而不是函数。可能正在运行的是创建 promise 对象时启动的一些异步任务。promise 构造函数回调可能会调用异步 API(如setTimeout、fetch等(，这可能会导致异步调用resolve。最好将此中间状态称为"挂起"(而不是"正在运行"(的承诺}