尝试学习一些现代 JS，特别是 ECMAScript 6 Promises。我正在玩这个简单的测试：
let slow = new Promise((resolve) => {
setTimeout(function()
{
console.log('slow');
resolve();
}, 2000, 'slow');
});
let instant = new Promise((resolve) => {
console.log('instant');
resolve();
});
let quick = new Promise((resolve) => {
setTimeout(function()
{
console.log('quick');
resolve();
}, 1000, 'quick');
});
Promise.all([slow, instant, quick]).then(function(results) {
console.log('finished');
}, function(error) {
console.log(error);
});我想要的是同时异步启动所有 Promise。当它们全部完成时并记录。在控制台中，这按预期显示：“即时”、“快速”、“慢速”和“完成”。
但是，如果我想确保“即时”在“慢速”完成之前不会回显/记录怎么办？也就是说，我希望控制台记录“快”、“慢”、“即时”和“完成”......但同时，它们仍然必须同时异步启动。
我怎样才能实现这个目标？
所以要明确一点，你想要在这里做的是立即启动所有的 Promise，并按每个 Promise 出现的特定顺序显示它们的结果，对吗？
在这种情况下，我可能会这样做：
let slow = new Promise((resolve) => {
setTimeout(function()
{
// Rather than log here, we resolve to the value we want to log
resolve('slow');
}, 2000, 'slow');
});
let instant = new Promise((resolve) => {
resolve('instant');
});
let quick = new Promise((resolve) => {
setTimeout(function()
{
resolve('quick');
}, 1000, 'quick');
});
// All Promises are now running. Let's print the results...
// First wait for the result of `slow`...
slow.then((result) => {
// Result received...
console.log(result);
// Now wait for the result of instant...
instant.then((result) => {
// Result received...
console.log(result);
// Now wait for the result of quick...
quick.then((result) => {
// Result received...
console.log(result);
}).then((result) => {
// Done
console.log('finished');
});
});
});请注意，与 cchamberlain 的 answer 不同，此方法不 等待所有 Promise 解决后再开始返回结果。它会返回输入的结果，但不会违反保持结果有序的要求。 （要验证这一点，请尝试将
quickinstant上面的代码有点乱，但幸运的是，使用 ES2017 中新的
async/awaitlet slow = new Promise((resolve) => {
setTimeout(function()
{
// Rather than log here, we resolve to the value we want to log
resolve('slow');
}, 2000, 'slow');
});
let instant = new Promise((resolve) => {
resolve('instant');
});
let quick = new Promise((resolve) => {
setTimeout(function()
{
resolve('quick');
}, 1000, 'quick');
});
// All Promises are now running. Let's print the results...
async function logResults(...promises) {
for (let promise of promises) {
console.log(await promise);
}
}
logResults(slow, instant, quick).then(() => console.log('finished'));尝试 Babel。注意：上述代码目前无法在没有 Babel 的现代浏览器中运行（截至 2016 年 10 月）。在未来的浏览器中它会的。
问题的一部分是日志记录是在
setTimeoutconst slow = new Promise((resolve) => {
setTimeout(() => {
console.log('slow - from setTimeout');
resolve('slow - from resolve');
}, 2000, 'slow');
});
const instant = new Promise((resolve) => {
console.log('instant - from setTimeout');
resolve('instant - from resolve');
});
const quick = new Promise((resolve) => {
setTimeout(() => {
console.log('quick - from setTimeout');
resolve('quick -from resolve');
}, 1000, 'quick');
});
Promise.all([slow, instant, quick]).then((results) => {
console.log('results -', results);
console.log('finished');
}, (error) => {
console.log(error);
});将值传递给
resolvePromise.all已更新
您不能同时启动它们并期望结果按照您使用当前代码要求的顺序记录。您可以执行以下操作：
let slow = new Promise((resolve) => {
setTimeout(() => resolve('slow'), 2000)
})
let instant = new Promise((resolve) => {
// In the future setImmediate can be used here to ensure async execution. For now, setTimeout with 0MS effectively does the same thing.
setTimeout(() => resolve('instant'), 0)
})
let quick = new Promise((resolve) => {
setTimeout(() => resolve('quick'), 1000)
})
Promise.all([slow, instant, quick]).then(function(results) {
for(let result of results) {
console.log(result)
}
console.log('finished')
}, function(err) {
console.error(err)
})这会将它们全部安排好，然后在完成后按正确的顺序打印。
如果问题的要求是
“即时”不会在“慢速”之前回显/记录
和
但同时，它们仍然必须同时开始 异步。
您只需要对传递给
Promise.all().then()Promise.all()console.log()如果要求是
“如何等待另一个承诺？”
或
“如何保证多个 Promise 的解析顺序？”
参见这个答案。
传递来自所有 Promise 的值数组 它被传递的可迭代对象。值数组维护 原始可迭代对象的顺序，而不是承诺的顺序 已解决。如果可迭代数组中传递的内容不是 保证，它会被Promise.all转换为 1。Promise.resolve
let slow = new Promise((resolve) => {
setTimeout(function(value) {
resolve(value);
}, 2000, "slow");
});
let instant = new Promise((resolve) => {
resolve("instant");
});
let quick = new Promise((resolve) => {
setTimeout(function(value) {
resolve(value);
}, 1000, "quick");
});
Promise.all([slow, instant, quick]).then(function(results) {
console.log("finished");
console.log(results.join("\n"))
}, function(error) {
console.log(error);
});首先，您的代码已经“同时”启动了所有 3 个 Promise。您还正确记录了“完成”。根据我对问题的理解，您想要按顺序处理承诺的结果，但让它们并行执行。
let slow = new Promise((resolve) => {
setTimeout(function()
{
resolve();
}, 2000);
});
let instant = new Promise((resolve) => {
resolve();
});
let quick = new Promise((resolve) => {
setTimeout(function()
{
resolve();
}, 1000);
});
instant.then(function(results) {
console.log("instant");
}).then(function(){return quick;}).then(function(results) {
console.log("quick");
}).then(function(){return slow;}).then(function(results) {
console.log("slow");
}).then(function(){ return Promise.all([slow, instant, quick]);}).then(function(results) {
console.log('finished');
}).catch(function(error) {
console.log(error);
});这将保证您能够按顺序处理决议。
注意：在您的示例中，您使用
setTimeoutPromise.all()您可以利用函数调用返回
Promiseconsole.log()resolve()reject().then()Promise.then()Promise.then()let results = [];
let pace = value => {console.log(value); results.push(value); return results};
let slow = () => new Promise((resolve) => {
setTimeout((value) => {
resolve(value);
}, 2000, "slow");
});
let instant = () => new Promise((resolve) => {
resolve("instant");
});
let quick = () => new Promise((resolve) => {
setTimeout((value) => {
resolve(value);
}, 1000, "quick");
});
slow().then(pace)
.then(instant).then(pace)
.then(quick).then(pace)
.then(res => console.log("finished, results:", res))
.catch(error => console.log(error));