我投票支持：

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]
}

您可以等待Promise.all（）：

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

要存储结果：

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

请注意，Promise.all很快就会失败，这意味着一旦提供给它的一个承诺被拒绝，那么整个承诺就会被拒绝。

const happy=（v，ms）=>new Promise（（resolve）=>setTimeout（（）=>resolve（v），ms））const sad=（v，ms）=>new Promise（（_，reject）=>setTimeout（（）=>reject（v），ms））承诺。所有（[快乐（'快乐'，100），悲伤（'悲伤'，50）]）.then（console.log）.catch（console.log）//“sad”

相反，如果您希望等待所有承诺兑现或拒绝，则可以使用Promise.allSettled。请注意，Internet Explorer本机不支持此方法。

const happy=（v，ms）=>new Promise（（resolve）=>setTimeout（（）=>resolve（v），ms））const sad=（v，ms）=>new Promise（（_，reject）=>setTimeout（（）=>reject（v），ms））承诺。一切都已解决（[快乐（'快乐'，100），悲伤（'悲伤'，50）]）.then（console.log）//[｛“status”：“已完成”，“value”：“快乐”｝，｛“status”：“拒绝”，“reason”：“悲伤”｝]

注意：如果您使用Promise.在拒绝发生之前完成的所有操作都不会回滚，因此您可能需要注意这种情况。例如如果你有5个动作，4个快速，1个慢速和慢速拒绝。这4个操作可能已经执行，因此您可能需要回滚。在这种情况下，考虑使用Promise.allSettled，同时它将提供哪些操作失败和哪些操作未失败的确切细节。

await Promise.all（[someCall（），anotherCall（）]）；正如已经提到的那样，它将充当线程围栏（在CUDA这样的并行代码中非常常见），因此它将允许其中的所有承诺在不相互阻止的情况下运行，但将阻止执行继续，直到解决所有问题。

另一种值得分享的方法是Node.js异步，如果任务直接与API调用、I/O操作等有限资源的使用相关联，它还允许您轻松控制通常需要的并发量。

// create a queue object with concurrency 2
var q = async.queue(function(task, callback) {
  console.log('Hello ' + task.name);
  callback();
}, 2);

// assign a callback
q.drain = function() {
  console.log('All items have been processed');
};

// add some items to the queue
q.push({name: 'foo'}, function(err) {
  console.log('Finished processing foo');
});

q.push({name: 'bar'}, function (err) {
  console.log('Finished processing bar');
});

// add some items to the queue (batch-wise)
q.push([{name: 'baz'},{name: 'bay'},{name: 'bax'}], function(err) {
  console.log('Finished processing item');
});

// add some items to the front of the queue
q.unshift({name: 'bar'}, function (err) {
  console.log('Finished processing bar');
});

Medium文章自动收录（阅读更多）

没有Promise.all（）还有另一种方法可以并行执行：

首先，我们有两个功能来打印数字：

function printNumber1() {
   return new Promise((resolve,reject) => {
      setTimeout(() => {
      console.log("Number1 is done");
      resolve(10);
      },1000);
   });
}

function printNumber2() {
   return new Promise((resolve,reject) => {
      setTimeout(() => {
      console.log("Number2 is done");
      resolve(20);
      },500);
   });
}

这是顺序的：

async function oneByOne() {
   const number1 = await printNumber1();
   const number2 = await printNumber2();
} 
//Output: Number1 is done, Number2 is done

这是平行的：

async function inParallel() {
   const promise1 = printNumber1();
   const promise2 = printNumber2();
   const number1 = await promise1;
   const number2 = await promise2;
}
//Output: Number2 is done, Number1 is done

更新：

最初的答案使正确处理拒绝承诺变得困难（在某些情况下是不可能的）。正确的解决方案是使用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;

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

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”）；})();