Javascript 速率限制问题，通过动态承诺请求循环

在向api发送多个请求时，我遇到了速率限制429的问题。我使用api的Node.js库通过Javascript es-6承诺发出请求

每个承诺接受两个参数，参数在每个请求中都会更改

我通过将承诺与.then（）链接，并包含一个延迟函数，该函数在？ms后返回一个已解决的承诺，从而解决了速率限制问题

let delay = (time = delay_ms) => (result) => new Promise(resolve => setTimeout(() => resolve(result), time));

大概是这样的：

请求（arg1、arg2）
.然后（延迟（300））
。然后（请求（arg1、arg2））
.然后（延迟（300））…

这解决了速率限制的问题，但是我不得不用这个解决方案编写大量的代码，这让我非常头疼，因为我将不得不编写大量的代码

我希望

arg1

和

arg2

生活在不同的数组中，这样我就可以遍历它们来动态构建承诺请求，并在每个请求之间包含一个延迟

我尝试使用forEach和for循环进行迭代，但请求都会在相互之间的毫秒内发出，再次产生速率限制429问题

在以下情况下是否有解决方案：

• 所有的

  arg1

  都可以存储在一个数组中

  let arr1=['USD'、'EUR'…]

• 所有的

  arg2

  都可以存储在一个数组中

  let arr2=[60300600…]

• 在这里，我可以使用

  arr1

  和

  arr2

  在每个请求之间使用

  delay（）

  动态创建承诺请求

我的代码如下所示：

requestPromise(arg1_a, arg2_a).then(res => delay(ms)).then(requestPromise(arg1_b, arg2_b)).then(res => delay(ms))...

const delay_ms = 100;

function delay(t = delay_ms) {
    return new Promise(resolve => {
        setTimeout(resolve, t);
    });
}

function iterate(a1, a2, t) {
    let index = 0;
    const len = Math.min(a1.length, a2.length);
    if (len === 0) {
        return Promise.reject(new Error("iterate(a1, a2, t) needs two non-zero length arrays"));
    }

    function run() {
        return requestPromise(a1[index], a2[index]).then(() => {
            index++;
            // if still more to process, insert delay before next request
            if (index < len) {
                return delay(t).then(run);
            }
        });
    }

    return run();
}

// sample usage
let arr1 = ['USD', 'EUR' ...];
let arr2 = [60, 300, 600 ...];

iterate(arr1, arr2, 500).then(() => {
    // all done here
}).catch(err => {
    // got error here
});

可能还有异步方面的帮助吗？我已经试过了，但似乎无法解决这个问题？也许是因为承诺和动态争论？？？不确定我是否理解如何将async Wait与动态承诺和迭代等结合起来

---

谢谢你的帮助

如果我正确理解您要查找的内容，您希望在每个请求之间有延迟地迭代数组，调用

requestPromise（x，y）

其中

x

和

y

来自每个数组

您可以这样做：

requestPromise(arg1_a, arg2_a).then(res => delay(ms)).then(requestPromise(arg1_b, arg2_b)).then(res => delay(ms))...

const delay_ms = 100;

function delay(t = delay_ms) {
    return new Promise(resolve => {
        setTimeout(resolve, t);
    });
}

function iterate(a1, a2, t) {
    let index = 0;
    const len = Math.min(a1.length, a2.length);
    if (len === 0) {
        return Promise.reject(new Error("iterate(a1, a2, t) needs two non-zero length arrays"));
    }

    function run() {
        return requestPromise(a1[index], a2[index]).then(() => {
            index++;
            // if still more to process, insert delay before next request
            if (index < len) {
                return delay(t).then(run);
            }
        });
    }

    return run();
}

// sample usage
let arr1 = ['USD', 'EUR' ...];
let arr2 = [60, 300, 600 ...];

iterate(arr1, arr2, 500).then(() => {
    // all done here
}).catch(err => {
    // got error here
});

const delay_ms=100；
功能延迟（t=延迟\u ms）{
返回新承诺（解决=>{
设置超时（解析，t）；
});
}
函数迭代（a1，a2，t）{
设指数=0；
常数长度=数学最小值（a1.长度，a2.长度）；
如果（len==0）{
return Promise.reject（新错误（“iterate（a1，a2，t）需要两个非零长度数组”）；
}
函数运行（）{
返回请求承诺（a1[索引]、a2[索引]），然后（（）=>{
索引++；
//如果还要处理更多，请在下一个请求之前插入延迟
如果（索引{
//全部在这里完成
}).catch（错误=>{
//这里有错误
});

这是通过创建一个承诺链来实现的，其中每个新请求都链接到前一个承诺链上，并且仅在延迟后执行。数组通过

索引

变量访问，该变量初始化为

0

，然后在每次迭代后递增

---

此函数需要两个非零长度数组，并将迭代到两个数组中较短数组的长度（如果由于某些原因，它们的长度不相等）。

Promises.all（）

可用于处理异步调用承诺的返回，但是为了处理并发请求的数量，http.request代码需要限制调用的数量。设置https.globalAgent.maxSocket=20对我来说是一个简单的解决方法。这显然是在请求作为节点客户端时使用的。

使用

async/await

和标准for循环应该非常简单

async function iterate(arr1, arr2) {
    for (let i = 0; i < arr1.length; i++) {
        await requestPromise(arr1[i], arr2[i]);
        await delay(300);
    }
}

let arr1 = ['USD', 'EUR'];
let arr2 = [60, 300, 600];
iterate(arr1, arr2);

异步函数迭代（arr1，arr2）{ for（设i=0；i 此实现假定数组的长度相同。

，

CTRL-F

->

陷阱4：必须记住处理错误。读一下。