了解node.js中对递归函数的承诺

Question

我正在尝试使用递归调用从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实现一起工作。任何帮助将不胜感激。

Answer 1

• 兑现承诺时，尽量做到纯正。避免使用具有副作用的函数，即不要在其自身作用域之外操作任何变量。
• 避免将回调传递给函数。仅将它们传递给Promise方法。您正在使用方法r_client.smembers()和调用getFromRedis方法进行此操作

我只能看到一个特定的错误，该错误会使您的脚本无法正常工作：

return [];

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

要重组脚本，有两点：

• 使用Q.nfcall辅助函数（等）避免直接处理回调样式的API。使用then于再变换其结果-同步返回树叶或后代，让计算的承诺。
• 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 ));
    });