Promise.all 替换？

Question

有没有什么方法可以让我在 Javascript 中调用多个异步函数，但在一个完成后立即获得调用响应，这与等待所有异步调用完成的 Promise.all 不同？ 我想要的是，并行运行异步调用，并在其他调用仍在运行时立即获得相应调用的响应，然后更新反应状态。

我已经将 Promise.all 用于多个异步调用，但它会在所有调用完成后给出响应。

Answer 1

您可以迭代一系列承诺并更改每个承诺解决方案的状态：

let state = null;

const p1 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve({p1: 1});
  }, 2000);
});
const p2 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve({p2: 2});
  }, 1000);
});
const p3 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve({p3: 3});
  }, 3000);
});

// Iterate promises
[p1, p2, p3].forEach(p => {
  p.then(res => {
    state = Object.assign({}, state, res);
    console.log(state);
  });
});

console.log(state);

您可以为此任务创建自己的Promise 方法：

if (!Promise.each) {
  Promise.each = function(promises, callback, error) {
    if (promises && Array.isArray(promises)) {
      promises.forEach(p => {
        p.then(res => {
          callback(res);
        }, err => {
          if (error) {
              error(err);
          } else {
              console.log(err);
          }          
        });
      });
    }
  }
}

// Usage
Promise.each([p1, p2, p3], updateState);

Answer 2

在您的问题中，“比更新...状态”是关键。您计划以这样一种方式更新状态，即一旦一个承诺“完成”，相应的状态就会更新。你一直在尝试这样的事情

async function f1(){ await Promise.resolve(); }
async funciton f2(){ await Promise.resolve(); }
async function fn(){ await Promise.resolve(); }

async function drvAsync(){
  const [r1, r2, rn] = await Promise.all([f1(), f2(), fn()]);
  u1(r1);
  u2(r2);
  un(rn);
}

其中 f[n] 是一个异步业务函数，u[n] 是一种处理其结果的方法。此架构在您的场景中是不可接受的。也许 fn 完成得比其他人更快，并且您想更早地更新第 N 个状态。

我的建议是完全不使用同步原语。相反，您应该单独处理结果。

function drv(){
  f1().then((r1)=>u1(r1)).catch((e)=>er(e));
  f2().then((r2)=>u2(r2)).catch((e)=>er(e));
  fn().then((rn)=>un(rn)).catch((e)=>er(e));;  
}

此架构将调用每个更新 (u[n]) 方法，而无需等待其他方法的结果。

Answer 3

只要您不使用 async/await，您就可以并行执行调用。请注意，浏览器对网络请求有连接限制，因此如果您执行例如 100 个调用，它将不是并行的，而是排队的。

当承诺解决时，您需要一个回调来执行。如果所有函数的回调都相同，而不是循环所有调用，则创建承诺并使用相同的函数解析。

function resolved(data) {
    // ...
}

const promise1 = new Promise(function(resolve, reject) {
    resolve('Success!');
}).then(resolved);

const promise2 = new Promise(function(resolve, reject) {
    resolve('Success!');
}).then(resolved);

Answer 4

这就是Promise.race 的用途：

Promise.race() 方法返回一个承诺，一旦可迭代中的一个承诺履行或拒绝，该承诺就会履行或拒绝，并带有来自该承诺的价值或原因。

例如：

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function main() {
  const promises = [
    sleep(1000).then(() => "world"),
    sleep(100).then(() => "hello"),
  ];
  const promisesWithIndices = promises.map((p, index) =>
    p.then((result) => ({result, index}))
  );
  while (promisesWithIndices.length > 0) {
    const {result, index} = await Promise.race(promisesWithIndices);
    console.log("%s -> %s", index, result);
    promisesWithIndices.splice(index, 1);
  }
}

main();  // prints "1 -> hello"; then prints "0 -> world" after a while