Javascript 履行承诺。所有承诺。所有承诺

我已经向一个服务器发出了400个请求，并将每个请求都放在承诺中

在单个promise.all中运行所有400个请求时，系统将崩溃

我已经将我的请求分成50个承诺（并将它们添加到promise.all中），然后将它们添加到另一个promise.all中

我如何才能分批执行承诺，并等待这些承诺完成后再进行下一步

// attach the other accounts a user has to the wrapper object
// **this is 400+ requests object, that has the requests in it**
// results are promises
const influencerAccounts = wrapper.map(p => addInfluencerAccounts(p));

// split the requests into chunks to stop the server falling over
const chunkedPromises = _.chunk(influencerAccounts, 50);

// promise.all on each chunk of promises/requests
// ????


// ...

return

我已经尝试过循环使用分块的promised数组（这是一个promises数组）和Promise.all，但这不会等到上一批完成后再发送下一批

谢谢

奥利

你一开始犯了很多人都犯的错误：

承诺。所有的

都不会运行任何东西。它只是等待已经运行的东西。当您将

influenceAccounts

数组分解成块时，您可能已经使服务器过载，因为您仍在同时发送400多个请求

相反，将

支出

数组分块处理，如下所示：

const results = [];
const promise =
    _.chunk(payout, 50).reduce(
        (p, chunk) =>
            p.then(chunkResults => {
                results.push(...chunkResults);
                return Promise.all(chunk.map(startRequest)); 
            })
        ,
        Promise.resolve([])
    )
    .then(() => results);

我在上面使用了

startRequest

而不是

createInfluencerWrapper

和

addinfluenceaccounts

，因为我不清楚您是否引入了一个或另一个来尝试进行分块。但如果不是这样，

startRequest

只是

addinfluenceaccounts（createInfluencerWrapper（entry））

它启动一个50个请求块，使用

Promise.all

等待所有请求完成，然后启动下一个50个请求块。“完成后再做”部分来自promise

reduce

成语，其简单形式如下：

someArray.reduce((p, entry) => p.then(() => doSomethingWith(entry)), Promise.resolve());

它从一个已解析的承诺开始，然后将一个

然后

处理程序钩住它来做下一件事，然后将一个

然后

处理程序钩住它来做下一件事，等等

---

如果您不喜欢结束

结果

，我们可以沿着

减少

链传递它；下面是上面的第一个版本：

const promise =
    _.chunk(payout, 50).reduce(
        ({p, results}, chunk) => ({
            p: p.then(chunkResults => {
                results.push(...chunkResults);
                return Promise.all(chunk.map(startRequest)); 
            }),
            results
        }),
        {p: Promise.resolve([]), results: []}
    )
    .then(({results}) => results);

---

我猜

createInfluencerWrapper

中有fetch请求，并且会发出请求，因此当您设置

wrapper

时，您已经发出了所有请求。如果您想限制请求的数量，那么将返回承诺的函数包装为，并且可能不允许在promise.all（something.map so）（最后一个代码块）中拒绝承诺然后对被拒绝的请求和成功的请求进行分类。您可能会发现，选择Bluebird promise库并使用

并发性设置会更容易。这将使您可以轻松地对400个请求进行编码，但可以单独指定要“飞行”的请求数量同时在处理它们的同时控制内存和资源的使用。这样，您就不必手动对它们进行分块，它会告诉您它们何时全部完成，并为您跟踪所有结果（按顺序）。或者，您可以复制和使用其他几种实现或。此外，从
承诺开始缩减会更简单。解析（[]）
，从而在每次迭代中通过承诺而不是承诺交付
结果。@Roamer-1888-Doh！谢谢！这在回顾中非常明显。：-）@T.J.Crowder——非常感谢——我的印象是，除非“解决”，否则承诺什么也做不了——非常感谢这种区别。这非常有用。@Ollie-我真的很高兴。你并不是唯一一个对他们有这种印象的人。：-）我想到的是
return.chunk（payout，50）.reduce（（p，chunk）=>{return p.then（results=>{return Promise.all（chunk.map（addinfluenceaccounts））.then（newResults=>results.concat（newResults））；}，Promise.resolve（[]）。