为什么 async.series 只产生一个输出

如果您只想按顺序向同一 API 发出十个请求（一个接一个，而不是并行），您可以这样做：

const got = require('got');
function runSequence(url, num) {
    let cntr = 0;
    let results = [];
    return new Promise(function(resolve, reject) {
        function checkDone(data) {
            ++cntr;
            results.push(data);
            if (cntr < num) {
                next();
            } else {
                resolve(results);
            }
        }
        function next() {
            got(url).then(response => {
                console.log(response.body);
                checkDone(response.body);
            }).catch(error => {
                console.log(error.response.body);
                checkDone(null);
            });
        }
        next();
    });
}
runSequence('https://randomuser.me/api/', 10).then(function(results) {
    // access array of results here
});

如果 API 调用不必一次执行一个，并且您可以同时将它们全部运行，则可以执行以下操作：

function runParallel(url, num) {
    let promises = [];
    for (let i = 0; i < num; i++) {
        promises.push(got(url));
    }
    return Promise.all(promises);
}
runParallel('https://randomuser.me/api/', 10).then(function(results) {
    // access array of results here
});

中止，而此处显示的两个序列选项在出现错误时继续。 可以将其更改为其他行为。 您没有指定所需的内容。

下面是运行序列的略有不同的方法：

function runSequence(url, num) {
    let cntr = 0;
    let results = [];
    function checkDone(data) {
        ++cntr;
        results.push(data);
        if (cntr < num) {
            return next();
        } else {
            return results;
        }            
    }
    function next() {
        return got(url).then(response => {
            return checkDone(response.body);
        }).catch(error => {
            return checkDone(null);
        });
    }
    return next();
}

下面是一个通用函数，用于重复某些异步操作 N 次。 您传入异步函数（返回一个 promise），您希望它按顺序重复的次数以及您希望它在出错时继续还是在错误时中止。

// pass a function that returns a promise
function repeatSequence(fn, num, continueOnError) {
    let cntr = 0;
    let results = [];
    checkDone(data) {
        ++cntr;
        results.push(data);
        if (cntr < num) {
            return next();
        } else {
            return results;
        }
    }
    function next() {
        return fn().then(checkDone).catch(function(err) {
            if (continueOnError) {
                return checkDone(null);
            } else {
                // reject on error
                throw err;
            }
        });
    }
    return next();
}

而且，如果您使用Bluebird Promise库，则可以使用以下Promise.mapSeries()：

function repeatSequence(fn, num, continueOnError) {
    var array = new Array(num);
    return Promise.mapSeries(array, function () {
        return fn().catch(function (err) {
            if (continueOnError) {
                return null;
            } else {
                throw (err);
            }
        });
    });
}

或者，如果您不想要continueOnError选项，它就会变成这样：

function repeatSequence(fn, num) {
    var array = new Array(num);
    return Promise.mapSeries(array, fn);
}

我必须同意Bergi的观点，即我们不能将回调与承诺混为一谈。尽管它们都是异步机制，但这两种结构中的每一个在本质上和哲学上都不应被一视同仁。

然而，正如jfriend00指出的那样，主要问题是在每一步中都没有调用"回调"。在使用非承诺库时，这将是正确的解决方案。

溶液

请在下面找到我的修改。本质是：

1. 此解决方案是有关如何仅使用 promise 实现它的示例。

2. 像 async-q 这样的端口可能会帮助你更好地使用现有库。

   const got = require('got');
   const async_q = require('async-q');
   var tenOperations = [];
   for(var i = 0; i < 10; i++) {
       tenOperations.push(doRequest);
   }
   function doRequest() {
       return got('https://randomuser.me/api/')
       .then(response => {
           console.log('resp', response.body);
           return JSON.parse(response.body);
       })
       .catch(error => {
           console.log('error', error.response.body);
           return error.response.body;
       });
   }
   async_q
   .series(tenOperations)
   .then (results => {
       console.log('results', results);
   })
   .done();