我正在尝试使用递归调用从 Redis 中获取数据，当成员返回 null 时停止并返回。

所以我的数据是这样添加的:

SADD parents.<name> <parent1> <parent2>
SADD parents.<parent1> <grandparent1> <grandparent2>
...

最终数据应该是这样的:

[
 {
     label: <name>,
     parents: [
         { label: <parent1>,
           parents: [ {label: <grandparent1>}, {label: <grandparent2> }] },
         { label: <parent2> }
     ]
 }
]

这是我弄乱的代码(从不同来源拼凑而成)，但我不知道我在做什么。不确定这段代码是否有用，我可能会偏离轨道。

var redis = require('node-redis');
var r_client = redis.createClient();
var Q = require('q');


function getFromRedis(nodeName){
        var ret = Q.defer();
        r_client.smembers('parents.' + nodeName,function(err,val){
                if (err) ret.reject(err);
                else {
                        var constructedObject={};  //this is our returned object
                        var dependents=[];
                        if (val)
                        {
                                for (var k in val){  //iterate the keys in val
                                        constructedObject.name = val[k];

                                        dependents.push(getFromRedis(val[k])
                                        .then(function(subVal){
                                                constructedObject[k]=subVal;
                                                return ret.promise;
                                        })
                                        );
                                }
                        }
                        else { return [] }

                }
                Q.all(dependents)
                .then(function(){ret.resolve(constructedObject);},ret.reject.bind(ret));

        });
                return ret;
}

getFromRedis( 'greg', function(out) {console.log('Final output: ' + JSON.stringify( out ))} );

我可以查看示例并从理论上了解它应该如何工作，但我无法理解它应该如何与 q 实现一起工作。任何帮助将不胜感激。

最佳答案

• 在处理 promises 时尽量保持纯洁。避免有副作用的函数，即操作任何超出其自身范围的变量。
• 避免将回调传递给函数。只将它们传递给 promise 方法。您正在使用 r_client.smembers() 和调用您的 getFromRedis 方法
来执行此操作

我只能看到一个会使您的脚本无法运行的特定错误:

return [];

对回调没有任何影响。因此，在这种情况下，ret 永远不会被解析。你会做 ret.resolve([]);返回； 如果有的话。但是，有更好的解决方案可以让您再次使用 return。

要重构你的脚本，有两点:

• 使用Q.nfcall helper function (等等)以避免直接处理回调式 API。使用 then 转换其结果 then - 同步返回树叶或对后代获取计算的 promise 。
• 使用Q.all首先，然后转换它的结果。不要向每个 dependent 添加处理程序，而是获取整个结果并一步构建 construct。

function getFromRedis(nodeName){
    return Q.ninvoke(r_client, "smembers", 'parents.' + nodeName).then(function(val) {
        // this is our returned object
        var constructedObject = {label: nodeName};
        if (val) {
            var dependents = val.map(function(par) {
                // get a promise for the next level
                return getFromRedis(nodeName+"."+par.toString());
            });
            return Q.all(dependents).then(function(dependentResults) {
                 constructedObject.parents = dependentResults;
                 return constructedObject;
            });
        } else { 
            return constructedObject; // without parents
        }
    });
}

getFromRedis( 'greg' ).done(function(out) {
    console.log('Final output: ' + JSON.stringify( out ));
});

关于javascript - 理解 node.js 中用于递归函数的 promise ，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18904745/