递归调用nodejs中的异步函数

Question

我执行异步搜索调用。搜索结果不是一次性返回的。我一次最多可以得到 200 个结果。对于下一组结果，我必须从第一组结果中提取书签。所以查询应该按顺序发生。我已经编写了以下代码，但它不起作用。下一个循环（for 循环）正在执行而没有完成第一个查询。我不知道如何解决这个问题。

var getQueryResult = function(resourcetypeStr, startTime, endTime, bookmark){ 
var promise = new Promise(function(resolve, reject) {
    var options = {
           OPTIONS
    };
    search(DESIGN_DOC, INDEX, options) //Async function
    .then(function (data) {
        resolve(data);
    })
    .catch(function(error){
        logger.error("Error querying database " + resourcetypeStr + ": " + error);
        return reject(error);
    });
});
    return promise;
};

var getRemainingData = function(resourcetypeStr, startTime, endTime, bookmark, number){

    var promise = new Promise(function(resolve, reject){
    var result;
    for(i = 0; i<number; i++ ){
        var data = getQueryResult(resourcetypeStr, startTime, endTime, bookmark).then (function(data){
        if(result){
            result = result.concat(data);
        }else{
            result = data;
        }
        if(data.row.lenth ===0){
            resolve(result);
        }
        bookmark = data.bookmark;
        return data;
    });
    }
    });
return promise;
};


var getResources = function (resourcetypeStr, list, startTime, endTime) {
var promise = new Promise(function(resolve, reject) {
    var options = {
            OPTIONS
    };
    return search(DESIGN_DOC, INDEX, options)//Async function
    .then(function (data){
        if(data.total_rows > 200){
            debugger;
            getRemainingData(resourcetypeStr, startTime, endTime, data.bookmark, function(result){
                resolve(data.concat(result));
            });
        }else{
            resolve(data);
        }
    })
    .catch(function(error){
        console.log("reject error :"+error);
        return reject(error);
    });
    });
    return promise;
};

我也试过了

function getRemainingData(resourcetypeStr, uuidQueryString, startTime, endTime, bookmark, number, callback) {
  var result; // clone collection
  (function getOne(resourcetypeStr, uuidQueryString, startTime, endTime, bookmark) {
      console.log("getOne is called");
    getRemainingData(resourcetypeStr, uuidQueryString, startTime, endTime, bookmark).then(function(data){
        if(result){
            result = result.concat(dataToJson(data));
        }else{
            result = dataToJson(data);
        }
        if(data.row.lenth ===0){
            callback(result);
        }else{
            setTimeout(getOne(resourcetypeStr, uuidQueryString, startTime, endTime, data.bookmark), 0);
        }
    } );
  })();
}

带有回调，但这是溢出堆栈。我不确定为什么在我的测试用例中只有 300 个结果，所以它应该只在这里运行一次。

Answer 1

你尝试过这样的事情吗？

var promise = new Promise(function(resolve, reject){
    var result,
        callback = function callback(data) {
            if (result) {
                result = result.concat(data);
            } else {
                result = data;
            }
            if (data.row.length ===0) {
                resolve(result);
            }
            else {
                getQueryResult(resourcetypeStr, startTime, endTime, bookmark).then(callback);
            }
        };
    getQueryResult(resourcetypeStr, startTime, endTime, bookmark).then(callback);
});
return promise;

当 getQueryResult 返回时，如果长度为 0，我们就完成了并且可以解析外部 promise，否则使用相同的回调再次调用 getQueryResult，直到长度为 0。所以而不是 for 循环，每个解析 getQueryResult如果需要，请调用下一个。

如果这与您的第二次尝试类似，请检查 data.row.length 的值，因为只有在 data.row.length 永远不会为 0 时，这才能无限。