我创建了一个助手函数waitAll，也许它可以让它更甜。它目前只在nodejs中工作，在浏览器chrome中不工作。

    //const parallel = async (...items) => {
    const waitAll = async (...items) => {
        //this function does start execution the functions
        //the execution has been started before running this code here
        //instead it collects of the result of execution of the functions

        const temp = [];
        for (const item of items) {
            //this is not
            //temp.push(await item())
            //it does wait for the result in series (not in parallel), but
            //it doesn't affect the parallel execution of those functions
            //because they haven started earlier
            temp.push(await item);
        }
        return temp;
    };

    //the async functions are executed in parallel before passed
    //in the waitAll function

    //const finalResult = await waitAll(someResult(), anotherResult());
    //const finalResult = await parallel(someResult(), anotherResult());
    //or
    const [result1, result2] = await waitAll(someResult(), anotherResult());
    //const [result1, result2] = await parallel(someResult(), anotherResult());

我投票支持：

await Promise.all([someCall(), anotherCall()]);

请注意，调用函数时，可能会导致意外结果：

// Supposing anotherCall() will trigger a request to create a new User

if (callFirst) {
  await someCall();
} else {
  await Promise.all([someCall(), anotherCall()]); // --> create new User here
}

但以下始终会触发创建新用户的请求

// Supposing anotherCall() will trigger a request to create a new User

const someResult = someCall();
const anotherResult = anotherCall(); // ->> This always creates new User

if (callFirst) {
  await someCall();
} else {
  const finalResult = [await someResult, await anotherResult]
}

在我的例子中，我有几个任务要并行执行，但我需要对这些任务的结果做一些不同的事情。

function wait(ms, data) {
    console.log('Starting task:', data, ms);
    return new Promise(resolve => setTimeout(resolve, ms, data));
}

var tasks = [
    async () => {
        var result = await wait(1000, 'moose');
        // do something with result
        console.log(result);
    },
    async () => {
        var result = await wait(500, 'taco');
        // do something with result
        console.log(result);
    },
    async () => {
        var result = await wait(5000, 'burp');
        // do something with result
        console.log(result);
    }
]

await Promise.all(tasks.map(p => p()));
console.log('done');

输出：

Starting task: moose 1000
Starting task: taco 500
Starting task: burp 5000
taco
moose
burp
done

（异步函数（）{功能等待（毫秒，数据）{console.log（'启动任务：'，数据，毫秒）；return new Promise（resol=>setTimeout（resolve，ms，data））；}var任务=[异步（）=>{var result=等待等待（1000，'moose'）；//做些有结果的事console.log（结果）；},异步（）=>{var result=等待等待（500，'taco'）；//做些有结果的事console.log（结果）；},异步（）=>{var result=等待等待（5000，'burp'）；//做些有结果的事console.log（结果）；}]await Promise.all（tasks.map（p=>p（）））；console.log（“one”）；})();

这可以通过Promise.allSettled（）实现，它类似于Promise.all（），但没有快速失败行为。

async function Promise1() {
    throw "Failure!";
}

async function Promise2() {
    return "Success!";
}

const [Promise1Result, Promise2Result] = await Promise.allSettled([Promise1(), Promise2()]);

console.log(Promise1Result); // {status: "rejected", reason: "Failure!"}
console.log(Promise2Result); // {status: "fulfilled", value: "Success!"}

注意：这是一个边缘功能，浏览器支持有限，因此我强烈建议为该功能添加polyfill。

更新：

最初的答案使正确处理拒绝承诺变得困难（在某些情况下是不可能的）。正确的解决方案是使用Promise.all：

const [someResult, anotherResult] = await Promise.all([someCall(), anotherCall()]);

原答覆：

只需确保在等待其中一个函数之前调用这两个函数：

// Call both functions
const somePromise = someCall();
const anotherPromise = anotherCall();

// Await both promises    
const someResult = await somePromise;
const anotherResult = await anotherPromise;

TL；博士

对并行函数调用使用Promise.all，当发生错误时，应答行为不正确。

首先，立即执行所有异步调用并获取所有Promise对象。其次，对Promise对象使用await。这样，当您等待第一个Promise来解决其他异步调用时，其他异步调用仍在进行。总的来说，您将只等待最慢的异步调用。例如：

// Begin first call and store promise without waiting
const someResult = someCall();

// Begin second call and store promise without waiting
const anotherResult = anotherCall();

// Now we await for both results, whose async processes have already been started
const finalResult = [await someResult, await anotherResult];

// At this point all calls have been resolved
// Now when accessing someResult| anotherResult,
// you will have a value instead of a promise

JSbin示例：http://jsbin.com/xerifanima/edit?js安慰

注意：只要第一个等待调用发生在所有异步调用之后，那么等待调用是在同一条线上还是在不同的线上并不重要。见JohnnyHK的评论。

更新：根据@bergi的回答，这个答案在错误处理中的时间不同，它不会在错误发生时抛出错误，而是在所有承诺都执行后抛出错误。我将结果与@jonny的提示进行比较：[result1，result2]=Promise.all（[async1（），async2（）]），检查以下代码片段

常量correctAsync500ms=（）=>{return new Promise（解析=>{setTimeout（resolve，500，'correct500msResult'）；});};常量correctAsync100ms=（）=>{return new Promise（解析=>{setTimeout（resolve，100，'correct100msResult'）；});};常量拒绝同步100ms=（）=>{return new Promise（（resolve，reject）=>{setTimeout（拒绝，100，'拒绝100毫秒错误'）；});};const asyncInArray=异步（fun1，fun2）=>{const label='测试数组中的异步函数'；尝试{console.time（标签）；常量p1=fun1（）；常量p2=fun2（）；const result=[await p1，wait p2]；console.timeEnd（标签）；}捕获（e）{console.error（'错误为'，e）；console.timeEnd（标签）；}};常量asyncInPromiseAll=async（fun1，fun2）=>{const label='使用Promise.all测试异步函数'；尝试{console.time（标签）；let[value1，value2]=等待Promise。all（[fun1（），fun2（）]）；console.timeEnd（标签）；}捕获（e）{console.error（'错误为'，e）；console.timeEnd（标签）；}};（异步（）=>{console.group（'无错误的同步功能'）；console.log（'无错误的同步函数：启动'）等待异步InArray（correctAsync500ms，correctAsync 100ms）；等待异步InPromiseAll（correctAsync500ms，correctAsync 100ms）；console.groupEnd（）；console.group（'带错误的同步功能'）；console.log（'带有错误的同步函数：start'）等待异步InArray（correctAsync500ms，rejectAsync100ms）；等待异步InPromiseAll（correctAsync500ms，rejectAsync100ms）；console.groupEnd（）；})();