Question

我有一个与远程API交互的应用程序。我必须提出大约10000（10k）的请求，而不是太快，反ddos保护会阻止我。意味着我需要添加一点延迟。

代码

 var promises = [];
 for(var i = 0 ; i < list.length;i++)
 {
  console.log("checking " + list[i]);
  promises.push(doRequest(token,Username));
 }

 Promise.all(promises).then(function()
 {
  console.log("done");
 },function(err){
  console.log("oops");
 });

doRequest 如下所示：

function doRequest(token,username)
{
  var checkUsername = { method: 'GET',
  url: link + username,
  headers: 
   { AUTHORIZATION: 'Bearer ' + token,
     Accept: 'application/json' } };
    return new Promise(function (resolve, reject) 
    {
      request(checkUsername , function (error, res, body) {
        try
        {
          var json = JSON.parse(body);
          if(json.success)
          {
            resolve(username);
          }
          else
          {
            reject(username);
          }
        }
        catch(exception)
        {
          console.log(body);
          reject(exception);
        }
      });
    });
}

似乎我每次都到JSON.parse（正文），它崩溃了，因为我发送的请求方式太快，远程服务器不认为我是垃圾邮件机器人，导致我的身体只是未定义或只是代码运行得太快导致相同的事情。

我如何在保持代码异步性的同时挽回这种情况，以便它仍然相对较快？

Answer 1

答案取决于您想要尝试和制作它的速度。允许您同时执行多少次请求等。这是一种可能的策略。您想要考虑的方法是计算出允许的并发请求数量，并将工作分解为同时运行的同步块。

// the number of simultaneous requests that wont cause problems
const allowedSimultaneous = 10

// create each chain
const chains = Array(allowedSimultaneous).fill(Promise.resolve())

// now build a synchronous list for each block
list.forEach((item, i) => {
  const chainIndex = i % allowedSimultaneous
  chains[chainIndex] = chains[chainIndex]
    .then(() => doRequest(token, Username))
})

// finally use .all() to catch when all chains are completed
Promise.all(chains).then(() => console.log('done'))

注意：这是未经测试的代码，但希望您明白这一点。您希望构建一定数量的并发链，每个链运行一组同步调用。这可确保并发请求的数量始终为allowedSimultaneous。

根本不需要延迟，因为只有allowedSimultaneous个呼叫在运行，但如果你确实需要某种延迟，那么你可以在每个doRequest之后延迟

Answer 2

如果您使用的版本的Node已经足够async/await，那么这是非常轻松的。您可以将请求分组，等待每个组，暂停（等待超时），然后继续。例如：

＆＃13;

function getGroups(start, end, list) {
  var promises = [];
  end = end > list.length ? list.length : end
  for (var i = start; i < end; i++) {
    console.log("checking " + list[i]);
    promises.push(doRequest(i));
  }
  return Promise.all(promises)
}

function doRequest(i) {
  // fake request
  return new Promise(resolve => setTimeout(() => resolve(i), 750))
}


async function get(list) {
  const group_size = 5
  const wait_time = 1500
  for (var i = 0; i < list.length; i += group_size) {
    console.log("getting group")
    let group_result = await (getGroups(i, i + group_size, list))
    console.log("results of group: ", group_result)
    console.log("Waiting")
    await new Promise(resolve => setTimeout(resolve, wait_time))

  }
}
let urls = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
get(urls)

＆＃13;

如果您只想在每个请求之间稍加延迟，可以在循环中使用async/await，例如：

＆＃13;

function doRequest(i) {
  /* fake request */
  console.log("requesting: ", i)
  return new Promise(resolve => setTimeout(() => resolve(i), 250))
}

let urls = [0, 1, 2, 3, 4, 5]

async function get() {
  let results = []
  for (url of urls) {
    results.push(await doRequest(url))
    await new Promise(resolve => setTimeout(resolve, 200))
  }
  return results
}
get().then(r => console.log("results: ", r))

＆＃13;

当然，您会想要进行错误检查等等......

Answer 3

NPM有一些限制承诺的套餐。这是最高的：

https://www.npmjs.com/package/promise-throttle

等待所有nodeJS请求完成并为它们添加一个小延迟

3 个答案: