Question

我目前正在开发一个程序，需要使用Promise.all来同时运行一些功能。但是在继续执行任务之前，我只需要完成两个诺言，然后运行.then（），我将如何去做？

示例：

await Promise.all([Task1(),Task2(),Task3(),Task4(),Task5()]);

仅当（例如）Task1和Task 4完成时，我需要它来继续执行代码。

我已经尝试通过使用while循环来尝试通过在结束时设置变量来等待Task1和Task2完成的过程，但是那样。根本不起作用。

Answer 1

在评论中，您似乎已经明确地说过，您知道事先有两个紧急情况比其他情况更紧急（在此示例中，是Task1和Task4）。

然后只需两次使用Promise.all：

const allResults = Promise.all([
    Promise.all([Task1(), Task4()])
    .then(([result1, result4]) => {
        // Those two are done, do what you like with `result1` and `result4`...
        return [result1, result4];
    }),
    Task2(),
    Task3(),
    Task5()
])
.then(([[result1, result4], result2, result3, result5]) => {
    // All five are done now, let's put them in order
    return [result1, result2, result3, result4, result5];
})
.then(/*...*/)
.catch(/*...*/);

在那儿，我通过重新映射整体then处理程序中的顺序来保留外链中的整体1、2、3、4、5。

最初，我认为您想等到任何完成两个任务，而不是特定的两个任务。没有内置的功能，但是编写起来很简单：

function enough(promises, min) {
  if (typeof min !== "number") {
    return Promise.all(promises);
  }
  let counter = 0;
  const results = [];
  return new Promise((resolve, reject) => {
    let index = 0;
    for (const promise of promises) {
      let position = index++;
      promise.then(
        result => {
          results[position] = result;
          if (++counter >= min) {
            resolve(results);
          }
        },
        reject
      );
    }
  });
}

实时示例：

function enough(promises, min) {
  if (typeof min !== "number") {
    return Promise.all(promises);
  }
  let counter = 0;
  const results = [];
  return new Promise((resolve, reject) => {
    let index = 0;
    for (const promise of promises) {
      let position = index++;
      promise.then(
        result => {
          results[position] = result;
          if (++counter >= min) {
            resolve(results);
          }
        },
        reject
      );
    }
  });
}

const delay = (ms, ...args) => new Promise(resolve => setTimeout(resolve, ms, ...args));
const rnd = () => Math.random() * 1000;

enough(
  [
    delay(rnd(), "a"),
    delay(rnd(), "b"),
    delay(rnd(), "c"),
    delay(rnd(), "d"),
    delay(rnd(), "e")
  ],
  2
)
.then(results => {
  console.log(results);
})
.catch(error => {
  console.error(error);
});

Answer 2

一种方法是通过构造随机承诺的新数组，然后仅等待它们：

let array = [Task1(),Task2(),Task3(),Task4(),Task5()];

// Select any two promises after running the randomization logic
let promises = Promise.all[array[1], array[3]];

promises
  .then(() => {
    // Do stuff here
  });

Answer 3

Promise.all()不能同时运行您的任务，它只在解决返回的Promise之前等待所有Promise都解决。

创建每个Promise后，您的任务将立即运行。

如果您要在执行特定任务后等待，请仅将这些任务包括在Promise.all中：

const tasks = [Task2(), Task3(), Task5()];
const result1 = await Promise.all([Task1(), Task4()]);
// Task1 and Task4 are done here
const result2 = await Promise.all(tasks);
// All remaining tasks are done here

Answer 4

我看过这样的把戏： Promise.all(promises.map(p => p.catch(() => undefined))); 不过很不安全。
原始答案：here

Answer 5

好的，据我了解，您想要做类似的事情

const importantOnes = [Task1(), Task2()];
const remainingOnes = [Task3(), Task4(), Task5()];
const priorityPromise = Promise.all(importantOnes);

priorityPromise.then(doPriorityStuff);
Promise.all([priorityPromise, ...remainingOnes]).then(processTheCompleteData);

如何等待Promise.all中的Promise.all中的2个完成，然后执行其他任务

5 个答案: