返回promise时，我在此递归函数中做错了什么

Question

I need to get the initial timestamps of all znodes in the zookeeper . I am using the getChildren method of node-zookeeper-client to do so. I am calling my getInitialTimeStamp recursively to traverse along the path. My function looks something like this

function getInitialTimeStamp(client,path){
    return new Promise((resolve,reject) => {
        client.getChildren(
            path,
            function(error,children,stats){
                //if children empty, return
                if (typeof children === 'undefined' || children.length <= 0) {resolve();} 

                timeStamp[path]= {ctime: stats.ctime, mtime: stats.mtime};  
                children.map(child => {
                    getInitialTimeStamp(client,path+'/'+child);
                });
        });
    });
}

it is being called like this

getInitialTimeStamp(client,path)
    .then(() => {
      console.log(timeStamp);
      console.log("finished");
});

The problem is I can not get my .then() part to run. I know this is related to returning promise but I do not know what is being done wrong here. Consider my lack of knowledge in promises and async programming and provide me with a solution.

Answer 1

there are two things wrong .... if children is not empty, you never resolve ... and your children.map may as well be a forEach the way you're using it

So, firstly, you want to resolve something if children has a length, and sescondly, you only want to do so once ALL the getInitialTimeStamp of the children is finished, by use of Promise.all

function getInitialTimeStamp(client,path){
    return new Promise((resolve,reject) => {
        client.getChildren(
            path,
            function(error,children,stats){
                //if children empty, return
                if (typeof children === 'undefined' || children.length <= 0) {
                    resolve();
                } 
                timeStamp[path]= {ctime: stats.ctime, mtime: stats.mtime};  
                // use promise.all to wait for all child timestamps
                Promise.all(children.map(child => getInitialTimeStamp(client,path+'/'+child)))
                // and then resolve this path
                .then(resolve);
        });
    });
}

Although that can be cleaned up a bit

function getInitialTimeStamp(client, path) {
    return new Promise((resolve, reject) => {
        client.getChildren(path, (error, children, stats) => {
            timeStamp[path]= {ctime: stats.ctime, mtime: stats.mtime};  
            resolve(Promise.all((children||[]).map(child => getInitialTimeStamp(client, path + '/' + child))));
        });
    });
}

but still no error checking is done ... ie test if error is truthy

Answer 2

I would suggest this type of implementation that promisifies at a lower level by promisifying client.getChildren() . That makes it a lot easier to write all your logic using promises and avoids common pitfalls of JaramandaX's implementation such as completely missing error handling and error propagation.

Since promises only resolve to a single value, when promisifying something that passes multiple values to its callback, you have to shoehorn each of the values into an object and resolve with that object.

Also, your implementation seems to be modifying some timeStamp global or higher scope variable which seems less than desirable. So, I've made it so you can optionally pass in an object to start with, but if you don't it will default to an empty object and, in either case, the function will return a promise that will resolve to the object filled with the desired properties, including a cnt property so you can more easily see how many are there.

getInitialTimeStamp() returns a promise that resolves to an object that contains your desired path properties.

// make promisified version that resolves to an object with properties on it
// Depending upon the situation, you might add this to the prototype rather than
// to an instance
client.getChildrenP = function(path) {
    return new Promise((resolve, reject) => {
        this.getChildren(path, (error, children, stats) => {
            if (error) return reject(error);
            resolve({children, stats});
        });
    });
}

// Returns a promise that resolves to a timeStamp object
// You can optionally pass in an object to be modified or that will default
// to an empty object.  In either case, the returned promise resolves to
// the finished object.
function getInitialTimeStamp(client, path, resultsObj){
    let obj = resultsObj || {cnt: 0};
    obj.cnt = obj.cnt || 0;
    return client.getChildrenP(path).then(results => {
        if (typeof results.children === 'undefined' || children.length <= 0) {
            // return results so far
            return obj;
        }
        ++obj.cnt;
        obj[path]= {ctime: results.stats.ctime, mtime: results.stats.mtime};  
        return Promise.all(children.map(child => {
            getInitialTimeStamp(client,path+'/'+child, obj);
        })).then(results => {
            return obj;
        });
    });
}

Usage:

getInitialTimeStamp(client, somePath).then(resultsObj => {
     // process resultsObj here
}).catch(err => {
    // process error here
});