最后async/await将很快在除 IE 之外的所有主要浏览器中得到支持。所以现在我们可以开始用async/编写更具可读性的代码，await但有一个问题。很多人像这样使用异步等待：
const userResponse = await fetchUserAsync();
const postsResponse = await fetchPostsAsync();
虽然这段代码是可读的，但它有一个问题，它会连续运行这些函数，直到用户的获取完成它才会开始获取帖子。解决方案很简单，我们需要并行获取资源。
所以我想做的是（用伪语言）：
fn task() {
result-1 = doAsync();
result-2 = doAsync();
result-n = doLongAsync();
// handle results together
combinedResult = handleResults(result-1, result-2);
lastResult = handleLastResult(result-n);
}
你可以这样写：
const responses = await Promise.all([
fetchUserAsync(),
fetchPostsAsync(),
]);
const userResponse = responses[0];
const postsResponse = responses[1];
这很容易吧？但是有一个问题！Promise.all具有快速失败行为，这意味着，一旦其中一个Promise被拒绝，它就会拒绝。可能您想要一个更强大的解决方案，我们负责处理任何提取的拒绝。幸运的是，有一个解决方案，只需使用async/await即可实现，无需使用Promise.all. 一个工作示例：
console.clear();
function wait(ms, data) {
return new Promise( resolve => setTimeout(resolve.bind(this, data), ms) );
}
/**
* This will run in series, because
* we call a function and immediately wait for it's result,
* so this will finish in 1s.
*/
async function series() {
return {
result1: await wait(500, 'seriesTask1'),
result2: await wait(500, 'seriesTask2'),
}
}
/**
* While here we call the functions first,
* then wait for the result later, so
* this will finish in 500ms.
*/
async function parallel() {
const task1 = wait(500, 'parallelTask1');
const task2 = wait(500, 'parallelTask2');
return {
result1: await task1,
result2: await task2,
}
}
async function taskRunner(fn, label) {
const startTime = performance.now();
console.log(`Task ${label} starting...`);
let result = await fn();
console.log(`Task ${label} finished in ${ Number.parseInt(performance.now() - startTime) } miliseconds with,`, result);
}
void taskRunner(series, 'series');
void taskRunner(parallel, 'parallel');
/*
* The result will be:
* Task series starting...
* Task parallel starting...
* Task parallel finished in 500 milliseconds with, { "result1": "parallelTask1", "result2": "parallelTask2" }
* Task series finished in 1001 milliseconds with, { "result1": "seriesTask1", "result2": "seriesTask2" }
*/注意：您将需要一个已async/await 启用的浏览器来运行此代码段（或 nodejs v7 及更高版本）
这样你就可以简单地使用try/catch来处理你的错误，并在parallel函数内部返回部分结果。
如果您对 Promise.all 的快速失败行为和解构赋值语法没有意见：
const [userResponse, postsResponse] = await Promise.all([
fetchUserAsync(),
fetchPostsAsync(),
]);
对于那些询问如何将其扩展到运行时确定的调用次数的人，您可以使用 2 个循环。第一个启动所有任务，第二个等待一切完成
console.clear();
function wait(ms, data) {
return new Promise( resolve => setTimeout(resolve.bind(this, data), ms) );
}
/**
* While here we call the functions first,
* then wait for the result later, so
* this will finish in 500ms.
*/
async function runTasks(timings) {
let tasks = [];
for (let i in timings) {
tasks.push(wait(timings[i], `Result of task ${i}`));
}
/* Want fast fail? use Promise.All */
//return Promise.All(tasks);
let results = [];
for (let task of tasks) {
results.push(await task);
}
return results;
}
async function taskRunner(fn, arg, label) {
const startTime = performance.now();
console.log(`Task ${label} starting...`);
let result = await fn(arg);
console.log(`Task ${label} finished in ${ Number.parseInt(performance.now() - startTime) } miliseconds with,`, result);
}
void taskRunner(runTasks, [50,100,200,60,500], 'Task List');我实际上只是做了同样的事情。通过使用 promises 然后使用 Promise.all 在最后同步它们，您可以执行许多并发请求，但请确保在完成之前返回所有结果。
在最后一个例子中看到这里：http : //javascriptrambling.blogspot.com/2017/04/to-promised-land-with-asyncawait-and.html
伪代码可以写成如下：
fn async task() {
result-1 = doAsync();
result-2 = doAsync();
result-n = doLongAsync();
try{
// handle results together
combinedResult = handleResults(await result-1, await result-2);
lastResult = handleLastResult(await result-n);
}
catch(err){
console.error(err)
}
}
result-1、result-2、result-n 将并行运行。combineResult 和 lastResult 也将并行运行。但是，一旦 result-1 和 result-2 可用，将返回 combineResult 值，即 handleResults 函数的返回，而一旦 result-n 可用，将返回 lastResult 值，即 handleLastResult。
希望这可以帮助