Javascript 每个API请求之间的延迟

我想使用API来获取价格数据。我需要发送100个请求，我需要在每个请求之间有一个延迟。太多了，没有得到429错误。我如何以实际的方式实现这一点。我用的是NodeJS

/* Get Sparkline data from CoinGecko*/
function getSparklineData (marketDataUSD) {
    return new Promise((resolve, reject) => {

        //Get sparkline for every id in marketDataUSD
        marketDataUSD.forEach((coin) => {
            // Get API market data from CoinGecko
            let reqSparklineDataUSD  =  unirest("GET", "https://api.coingecko.com/api/v3/coins/"+coin.id+"/market_chart?vs_currency=usd&days=24hours");

            //Wait for response from CoinGecko
            reqSparklineDataUSD.end((resSparklineDataUSD) => {
                //Checking for request errors
                if (!resSparklineDataUSD.error) {
                    console.log(coin.id)
                    // console.log(resSparklineDataUSD.body.prices)
                    resolve(resSparklineDataUSD.body)
                } else {
                    console.log("Something went wrong:\n"+ resSparklineDataUSD.error)
                    reject()
                }
            });
        });
    })
}

---

您还没有说明如何存储结果，但这里有一种方法适用于任何在数组中存储结果的Node.js的模糊最新版本

首先，让我们执行一个函数，该函数返回一个承诺，用于请求一枚硬币。显然，

unirest

函数的返回值是一个承诺，因此：

async function getCoinGecko(coinId) {
    const reqSparklineDataUSD = await unirest("GET", "https://api.coingecko.com/api/v3/coins/"+coinId+"/market_chart?vs_currency=usd&days=24hours");
    return resSparklineDataUSD.body;
}

让我们给自己一个基于

setTimeout

的承诺：

// A promise-enabled delay function
function delay(ms, value) {
    return new Promise(resolve => setTimeout(resolve, ms, value));
}

现在，我们可以使用一个

async

函数返回一个结果数组的承诺（例如）：

或者这里是最后一个函数的一个版本，它返回硬币ID=>数据的

映射的承诺：

// An async function returns a promise and can use `await` to wait for promises
async function getSparklineData(marketDataUSD) {
    const results = nw Map();
    let first = true;
    for (const {id} of marketDataUSD) {
        if (first) {
            // Don't delay on the first loop
            first = false;
        } else {
            // Delay on the second loop onward
            await delay(lengthOfDelayInMS);
        }
        // Get this result
        results.set(id, await getCoinGecko(id));
    }
    return results;
}

您还没有说明如何存储结果，但这里有一种方法适用于任何在数组中存储结果的Node.js的模糊最新版本

首先，让我们执行一个函数，该函数返回一个承诺，用于请求一枚硬币。显然，
unirest
函数的返回值是一个承诺，因此：

async function getCoinGecko(coinId) {
    const reqSparklineDataUSD = await unirest("GET", "https://api.coingecko.com/api/v3/coins/"+coinId+"/market_chart?vs_currency=usd&days=24hours");
    return resSparklineDataUSD.body;
}

让我们给自己一个基于
setTimeout
的承诺：

// A promise-enabled delay function
function delay(ms, value) {
    return new Promise(resolve => setTimeout(resolve, ms, value));
}

现在，我们可以使用一个
async
函数返回一个结果数组的承诺（例如）：

或者这里是最后一个函数的一个版本，它返回硬币ID=>数据的
映射的承诺：

// An async function returns a promise and can use `await` to wait for promises
async function getSparklineData(marketDataUSD) {
    const results = nw Map();
    let first = true;
    for (const {id} of marketDataUSD) {
        if (first) {
            // Don't delay on the first loop
            first = false;
        } else {
            // Delay on the second loop onward
            await delay(lengthOfDelayInMS);
        }
        // Get this result
        results.set(id, await getCoinGecko(id));
    }
    return results;
}

unirest
请求对象是承诺，因此您应该使用它，而不是使用
newpromise
创建承诺。然后使用
wait
对请求排序：

function async getSparklineData (marketDataUSD) {
    let results = [];
    for (let coin of marketDataUSD) {
        let reqSparklineDataUSD = await unirest.get("https://api.coingecko.com/api/v3/coins/"+coin.id+"/market_chart?vs_currency=usd&days=24hours");
        console.log(coin.id):
        results.push(resSparklineDataUSD.body);
    }
    return results;
}

调用方可以捕获任何错误：

getSparklineData(marketDataUSD)
    .then(results => process(results))
    .catch(err => console.log("an error occurred", err));

unirest
请求对象是承诺，因此您应该使用它，而不是使用
newpromise
创建承诺。然后使用
wait
对请求排序：

function async getSparklineData (marketDataUSD) {
    let results = [];
    for (let coin of marketDataUSD) {
        let reqSparklineDataUSD = await unirest.get("https://api.coingecko.com/api/v3/coins/"+coin.id+"/market_chart?vs_currency=usd&days=24hours");
        console.log(coin.id):
        results.push(resSparklineDataUSD.body);
    }
    return results;
}

调用方可以捕获任何错误：

getSparklineData(marketDataUSD)
    .then(results => process(results))
    .catch(err => console.log("an error occurred", err));

您的代码将多次尝试解析承诺（因为解析调用在forEach中）-您的第一个任务是“promisify”unirest调用，然后您可以添加延迟，类似于您的代码将多次尝试解析承诺（因为解析调用在forEach中）-您的第一个任务是“promisify”unirest调用，然后您可以添加一个delays，例如注意整个
新承诺
是不必要的，因为
unirest
已经返回了一个承诺。您还可以使用
constdelay=require（'util'）来代替DIY delay函数。promisify（setTimeout）
@CherryDT-是吗？感叹谢谢。：-）我真傻，以为这不是OP的代码如何使用它的。是的，你不必知道，但这样答案就改进了：）请注意，整个
新承诺
是不必要的，因为
unirest
已经返回了一个承诺。您还可以使用
constdelay=require（'util'）来代替DIY delay函数。promisify（setTimeout）
@CherryDT-是吗？感叹谢谢。：-）我真傻，以为这不是OP的代码如何使用它的。是的，你不必知道，但这样答案就改进了：）