Javascript 我保证，全部替换？

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

---

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

只要不使用async/wait，就可以并行执行这些调用。请注意，浏览器对网络请求有连接限制，因此，如果执行例如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);

这是为了：

Promise.race（）

方法返回一个承诺，该承诺在iterable中的一个承诺实现或拒绝时立即实现或拒绝，并带有该承诺的值或原因

例如：

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

---

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

let state=null；
常量p1=新承诺（（解决、拒绝）=>{
设置超时（（）=>{
解析（{p1:1}）；
}, 2000);
});
常量p2=新承诺（（解决、拒绝）=>{
设置超时（（）=>{
解析（{p2:2}）；
}, 1000);
});
常量p3=新承诺（（解决、拒绝）=>{
设置超时（（）=>{
解析（{p3:3}）；
}, 3000);
});
//重复承诺
[p1，p2，p3].forEach（p=>{
p、 然后（res=>{
state=Object.assign（{}，state，res）；
console.log（状态）；
});
});
console.log（状态）在您的问题中，短语“更新…状态”是关键。您计划以这样一种方式更新状态，即一旦一个承诺“完成”，相应的状态就会更新。你一直在尝试这样的事情

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]）方法，而无需等待其他方法的结果。
您是否还需要
Promise.all（）
的行为，或者不需要？我想您正在寻找。为了更好地理解Promise.race，请看您所描述的只是在所有承诺中添加相同的回调，这真的是您想要的吗？我想调用异步函数，我需要每个函数的响应。但是使用promise.all，当所有呼叫成功完成时，我会得到所有响应。我想要的是，调用是异步进行的，每次调用完成后我都会得到响应。不，承诺。仅比赛不是解决方案，你只需要OP愿意具备的条件之一（从那以后没有办法，只能处理下一个承诺的解决）。@Kaido:怎么不？您可以重复运行
Promise.race
，例如，每次都在一个较小的数组上运行。（添加了一个示例。）您现在远不是只有Promise.race，您使用的迭代器可以直接使用，方法是将异步
while
中的迭代器移动到一个简单的回调，您可以设置为所有Promise…这是正确的！在我的场景中，我有一个项目列表，其长度未知。如何在我当前的场景中使用它
items.forEach（item=>{apiCall（item）.then（…）}）
它会并行工作吗？是的，它会。第一阶段apiCall将开始为每个项目运行。在第二阶段，than/catch中的回调将被适当地调用。还有一件事@mx.Wolf，我尝试了您的实现，它工作得很好。现在，我怎么能等到一切都完成，不管其中有没有错误？哦，那是另一个故事。这次您确实使用了Promise.all，但在async（）=>{try{wait apiCall（item）}catch（e）{log（e）}}或类似的构造中包装每个apiCall，以显示对Promise没有拒绝的迹象。allI通过在Promise中包装每个api调用来处理它。首先，在“然后”中更新状态，然后解决或拒绝承诺。并在数组中添加所有调用，并使用promise.all等待all。状态，分别在“then”中更新，同时我们也在promise.all中等待所有调用完成。谢谢老实说，我会选择
Promise.each=函数each（iterable，oncompleted，onRejected）{for（iterable的常量值）this.resolve（value）.then（oncompleted，onRejected）；}我的2美分：失去对新承诺的控制是IMM次优的。您可能希望至少返回映射输入的结果，而不是一个无菌的forEach。这样一个人就可以做到承诺。全部（承诺。每个（承诺，doSomethingForEach））。然后（dosomethingwhalldone）。