Javascript 如何以组方式调用一个异步函数？

很抱歉，我可能无法清楚地描述这个问题。我会尝试：

现在我有一个异步函数，它获取数据并执行一些操作，例如

function myFunction(num: number):Promise<void> {
   return new Promise((resolve) => {
     console.log(num);
     return;
   });
} 

如果我必须使用此功能，如何实现这一点？我必须确保此函数的前五个调用已解决，然后再对下五个函数进行加速调用。我知道这看起来很奇怪，我想把我现在的问题抽象成这个数字问题

---

感谢您的任何意见或想法。

我将使用生成器，或者由于您使用的是typescript，您可以使用es7 async/await语法，使用lodash您可以执行以下操作：

(async function(){
  const iterations: number = 2;
  const batchSize: number = 5;
  let tracker: number = 0;
  _.times(iterations, async function(){
     // We execute the fn 5 times and create an array with all the promises
     tasks: Promise[] = _.times(batchSize).map((n)=> myFunction(n + 1 + tracker))
     await tasks // Then we wait for all those promises to resolve
     tracker += batchSize;
  })
})()

如果愿意，可以使用for/while循环替换lodash

检查

---

如果我没有正确理解，或者代码有问题，请告诉我，我会更新答案。

您可以通过将数组分块，并使用

array#map

和

Promise#all

处理这些分块来实现这一点。然后，您可以使用

数组#reduce

将块处理串在一起：

runChunkSeries([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 5, someAsyncFn);

// our placeholder asynchronous function
function someAsyncFn(value) {
  return new Promise((resolve) => {
    setTimeout(resolve, Math.random() * 5000);
  }).then(() => console.log(value));
}

function runChunkSeries(arr, chunkSize, fn) {
  return runSeries(chunk(arr, chunkSize), (chunk) => Promise.all(chunk.map(fn)));
}

// Run fn on each element of arr asynchronously but in series
function runSeries(arr, fn) {
  return arr.reduce((promise, value) => {
    return promise.then(() => fn(value));
  }, Promise.resolve());
}

// Creates an array of elements split into groups the length of chunkSize
function chunk(arr, chunkSize) {
  const chunks = [];
  const {length} = arr;
  const chunkCount = Math.ceil(length / chunkSize);

  for(let i = 0; i < chunkCount; i++) {
    chunks.push(arr.slice(i * chunkSize, (i + 1) * chunkSize));
  }

  return chunks;
}

runChunkSeries（[1,2,3,4,5,6,7,8,9,10]，5,someAsyncFn）；
//我们的占位符异步函数
函数someAsyncFn（值）{
返回新承诺（（解决）=>{
setTimeout（解析，Math.random（）*5000）；
}).然后（（）=>console.log（值））；
}
函数runChunkSeries（arr、chunkSize、fn）{
返回runSeries（chunk（arr，chunkSize），（chunk）=>Promise.all（chunk.map（fn））；
}
//异步但串联地在arr的每个元素上运行fn
函数运行系列（arr、fn）{
返回arr.reduce（（承诺，值）=>{
返回承诺。然后（（）=>fn（值））；
}，Promise.resolve（））；
}
//创建一个元素数组，将其拆分为chunkSize长度的组
功能块（arr、chunkSize）{
常量块=[]；
常数{length}=arr；
const chunkCount=Math.ceil（长度/块大小）；
for（设i=0；i

---

这是一个有效的解决方案。

使用

async

/

wait

实际上非常简单：

(async function() {
    var i = 0;
    while (true) {
        for (var promises = []; promises.length < 5; ) {
            promises.push(myFunction(i++));
        }
        await Promise.all(promises);
    }
}());

（异步函数（）{
var i=0；
while（true）{
对于（var promissions=[]；promissions.length<5；）{
promises.push（myFunction（i++））；
}
等待承诺。所有（承诺）；
}
}());

这是打字脚本吗？如果是这样的话，你应该添加标记确保你一次只调用5次myFunction-然后用Promise.all等待每一组5次-但是，由于这是typescript，可能有一种完全不同的方式-它可能不是typescript，很可能是这样的。。但它可能是Flow:）您的

myFunction

从未调用

resolve

？！对我是用打字机写的。谢谢@Zagen的回复！我想知道是否有一种方法不使用

async

或

wait

。在我目前的发展中，规则不允许我们使用这些。我可以使用Promise.all（），但我真的不知道如何编写这段代码。@Lubor，是的，你当然可以不用async/await（禁止使用奇怪的东西），你可以选择Promise，甚至是常规回调，但代码不会这么简单。检查SimpleJ answer，这是一个很好的实现，它只使用承诺。

(async function() {
    var i = 0;
    while (true) {
        for (var promises = []; promises.length < 5; ) {
            promises.push(myFunction(i++));
        }
        await Promise.all(promises);
    }
}());