你可以async完全放弃，async/await很容易地去。

Promise您的请求和使用 async/await

只是request变成一个Promise这样你就可以await了。

更好的是使用request-promise-native已经使用原生 Promise 包装了请求。

串行示例

从那时起，这是一个灌篮async/await：

const rp = require('request-promise-native')

const users = [1, 2, 3, 4]
const results = []

for (const idUser of users) {
  const result = await rp('http://foo.com/users/' + idUser)

  results.push(result)
}

并行示例

现在，上述解决方案的问题在于它很慢 - 请求是串行运行的。大多数时候这并不理想。

如果您不需要下一个请求的前一个请求的结果，只需继续执行 aPromise.all来触发并行请求。

const users = [1, 2, 3, 4]

const pendingPromises = []
for (const idUser of users) {
  // Here we won't `await` on *each and every* request.
  // We'll just prepare it and push it into an Array
  pendingPromises.push(rp('http://foo.com/users/' + idUser))
}

// Then we `await` on a a `Promise.all` of those requests
// which will fire all the prepared promises *simultaneously*, 
// and resolve when all have been completed
const results = await Promise.all(pendingPromises)

错误处理

错误处理async/await由普通try..catch块提供，为简洁起见，我已将其省略。

如果您有许多（数千）个 url 需要处理，最好定义一个批处理大小并递归调用 process 函数来处理一个批处理。

最好限制活动连接的数量，您可以使用它来限制活动连接或一定时间内的连接（每秒仅 5 个）。

最后但并非最不重要的; 如果你使用Promise.all你想确保当一个Promise被拒绝时，不是所有的成功都会丢失。您可以捕获被拒绝的请求并返回一个Fail类型对象，然后它会使用此 Fail 类型进行解析。

代码看起来像这样：

const async = require("async");
//lib comes from: https://github.com/amsterdamharu/lib/blob/master/src/index.js
const lib = require("lib");
const request = require("request");

const Fail = function(reason){this.reason=reason;};
const isFail = o=>(o&&o.constructor)===Fail;
const requestAsPromise = fullUri =>
  new Promise(
    (resolve,reject)=>
      request({
        url: fullUri
      }, 
      (err, res, body) => {
        console.log("Request callback fired...");
        if (err || res.statusCode !== 200) reject(err);
        console.log("Success:",fullUri);
        resolve([res,body]);
      })
  )
const process = 
  handleBatchResult =>
  batchSize =>
  maxFunction =>
  urls =>
    Promise.all(
      urls.slice(0,batchSize)
      .map(
        url=>
          maxFunction(requestAsPromise)(url)
          .catch(err=>new Fail([err,url]))//catch reject and resolve with fail object
      )
    )
    .then(handleBatch)
    .catch(panic=>console.error(panic))
    .then(//recursively call itself with next batch
      _=>
        process(handleBatchResult)(batchSize)(maxFunction)(urls.slice(batchSize))
    );

const handleBatch = results =>{//this will handle results of a batch
  //maybe write successes to file but certainly write failed
  //  you can retry later     
  const successes = results.filter(result=>!isFail(result));
  //failed are the requests that failed
  const failed = results.filter(isFail);
  //To get the failed urls you can do
  const failedUrls = failed.map(([error,url])=>url);
};

const per_batch_1000_max_10_active = 
  process (handleBatch) (1000) (lib.throttle(10));

//start the process
per_batch_1000_max_10_active(largeArrayOfUrls)
.then(
  result=>console.log("Process done")
  ,err=>console.error("This should not happen:".err)
);

在您handleBatchResult可以将失败的请求存储到文件中以供稍后尝试const [error,uri] = failedResultItem;，如果大量请求失败，您应该放弃。

之后handleBatchResult还有一个.catch，那就是你的恐慌模式，它不应该，所以我倒是建议失败有管道错误记录到文件（Linux版）。