Question

我有两个创建promises的异步函数。两个函数都使用相同的输入i。

async function1(i) {}
async function2(i) {}

我将多次使用不同的输入值调用这些函数，并且我希望尽可能提高代码的效率，因此我希望对promises进行排队，并使用Promise.all()将它们并行运行。

但是，我希望得到一个结果作为我的最终输出，这将是一个像这样的对象数组：

[
  {
    input: i,
    result1: result1,
    result2: result2
  },
  ...
]

我已经完成了两个独立的步骤：

＆＃13;

async function function1(i) {
  return i * i
}

async function function2(i) {
  return i * i * i
}

async function main() {
  var promises = []

  for (let i = 0; i < 10; i++) {
    let promise = function1(i)
      .then(function(result1) {
          return {i:i, result1:result1}
      });

    promises.push(promise)
  }

  var final = await Promise.all(promises)
  
  var promises2 = [];
  
  for (let i = 0; i < 10; i++) {
    let promise = function2(i)
    .then (function(result2) {
      final[i]['result2'] = result2;
    });
    
    promises2.push(promise);
  }
  
  await Promise.all(promises2)
  
  console.log(final)

}

main()

＆＃13;

但是，我觉得这可以使用一个Promise.all()来完成。你能告诉我怎么样吗？

Answer 1

async function function1(i)
{
    return i * i
}

async function function2(i)
{
    return i * i * i
}

async function main()
{
    const promises = [];

    for (let i = 0; i < 10; i++)
        promises.push(function1(i), function2(i));

    const results = await Promise.all(promises);
    const data = [];

    for (let i = 0; i < 10; i++)
    {
        const [result1, result2] = results.slice(i * 2, i * 2 + 2);
        data.push({ i, result1, result2 });
    }

    console.log(data);
}

main();

这应该顺利而迅速地进行。如果您没有function1，函数function2和Promise会返回await，因此将它们推送到promises数组是不言自明的。

然后你等待Promise.all，等待所有被解雇的所有20个承诺完成。最后，第二个循环遍历返回的promise。

在我的代码中，我使用了destructuring assignments。我假设您可以使用这些功能，因为您使用的是异步功能，这意味着您可以使用ES2017。

Answer 2

编辑：333的回答是正确的，不是我的回答。该解决方案将在队列中有2个批次。

我想我明白了：

＆＃13;

console.log("start")

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function function1(i) {
  await sleep(2000);
  return i * i
}

async function function2(i) {
  await sleep(2000);
  return i * i * i
}

async function main() {
  var promises = []

  for (let i = 0; i < 10; i++) {
    let a = function1(i);
    
    let b = function2(i);
    
    let promise = Promise.all([a,b]).then(
      function([resulta,resultb]) {
          return {i:i, result1: resulta, result2: resultb}
      });

    promises.push(promise)
  }

  var final = await Promise.all(promises)
  
  
  console.log(final)

}

main()

＆＃13;

请注意，我添加了一个sleep函数来测试这些函数的并行化。一切都在2秒内运行，所以我认为它已经过优化。

将两个promise的结果输出到单个对象中

2 个答案: