Add additional parameters to callback function

Question

I'm building a system in Node.js that is supposed to find all files in an array of folders, stat them, and then do some additional work using that information.

I'm using fs.readdir() to get all the files synchronously from each of the folders. My code looks like this:

for(i=0,max=paths.length; i<max; i++) {
    var path = paths.pop();
    console.log("READING PATH: " + path);
    fs.readdir(path, function(err, files) { handleDir(err, files, path); });
}

The problem is that, depending on how fast the readdir() executes, handleDir() is getting the wrong path. This happens because by the time the callback runs, the next loop has already started - meaning that the path variable has changed.

So, what I need to do is somehow lock that path variable to it's specific callback function. I can't think of any good way to do this - anyone have some ideas?

Answer 1

There is no block scope, so use a function for scope.

for(var i=0, path, max=paths.length; i<max; i++) {
    path = paths.pop();
    console.log("READING PATH: " + path);
    handlePath( path );
}
function handlePath ( path ) {
    fs.readdir(path, onPathRead);
    function onPathRead (err, files) {
        handleDir(err, files, path);
    }
}

Answer 2

This is one of the more annoying parts of JS for me. An alternative to creating a separate function (as @generalhenry demonstrated) is to wrap the code in an anonymous function that's executed before the path variable changes.

for(i=0,max=paths.length; i<max; i++) {
    var path = paths.pop();
    console.log("READING PATH: " + path);
    fs.readdir(path,
        (function(p){
            return function(err, files) {
                handleDir(err, files, p);
            };
        })(path);
    );
}

Either way, the important point is that the function's context (anonymous or not) is initiated before the value of the path variable is reassigned.

Answer 3

This is indeed an annoying feature of Javascript, so much so that Coffeescript (which is a language that compiles down to Javascript) has a specific way of dealing with it, the do operator on for . In Coffeescript your original function would be:

for path in paths
     fs.readdir path, (err, files) -> handleDir(err, files, path)

and the solution to your problem would be:

for path in paths
   do (path) ->
     fs.readdir path, (err, files) -> handleDir(err, files, path)

Answer 4

I was looking for the same thing and end up with the solution and here it's a simple example if anybody wants to go through this.

var FA = function(data){
   console.log("IN A:"+data)
   FC(data,"LastName");
};
var FC = function(data,d2){
   console.log("IN C:"+data,d2)
};
var FB = function(data){
   console.log("IN B:"+data);
    FA(data)
};
FB('FirstName')

Answer 5

Great solution from generalhenry, but be careful if you're going to use a try/catch structure inside the callback function

function handlePath ( path ) {
    fs.readdir(path, onPathRead);
    function onPathRead (err, files) {
        try {
            handleDir(err, files, path);
        } catch (error) {
            var path = 'something_else'; // <<--- Never do this !!!
        }     
    }
}

Never try to redeclare the same var in a catch block, even if the catch block is never invoked, the path var is reset and you will find it as 'undefined' when the callback is executed. Try this simple example:

function wrapper(id) {
    console.log('wrapper id:' + id);
    setTimeout(callback, 1000);
    function callback() {
        try {
            console.log('callback id:' + id);
        } catch (error) {
            var id = 'something_else';
            console.log('err:' + error);
        }
    }
}

wrapper(42);

This will output:

wrapper id:42
callback id:undefined