Node.js calling a callback function inside a callback

Question

I started learning node.js by reading Node JS in Action book recently. This is probably a newbie question, but after reading several posts of callback functions and javascript scope of variables, I still have problem understand the idea behind this code in chapter 5 of the book.

function loadOrInitializeTaskArray(file, cb) {
  fs.exists(file, function(exists) {
    var tasks = [];
    if (exists) {
      fs.readFile(file, 'utf8', function(err, data) {
        if (err) throw err;
        var data = data.toString();
        var tasks = JSON.parse(data || '[]');
        cb(tasks);
      });
    } else {
      cb([]); 
    }
  });
}

function listTasks(file) {
  loadOrInitializeTaskArray(file, function(tasks) {
    for(var i in tasks) {
      console.log(tasks[i]);
    }
  });
}

It includes three callback functions divided in two functions. listTasks(..) is called first and it calls loadorInitializeTaskArray(.. ) later. My problem starts here, how is this call handle by node? loadOrInitializeTaskArray takes two arguments and the second one is the callback function which shouldn't accept any parameters according to is signature but it does!!
when does cb(..) get called in loadorInitializeTaskArray and what is that (the same function that calls helper function)?

"tasks" is an array declared inside function loadOrInitializeTaskArray, how do we have access to it in listTasks(..) function?

I know in Javascript, scope of a variable is inside the function it define and all nested functions. But I have a hard time understanding it here. So can someone explain what is going on here? Thank you

Vishal · Accepted Answer · 2014-12-10 05:27:58Z

You really are having a hard time in understanding the scope of variable inside the nested functions. So, lets start with it.
Let's consider this code

function foo(){
  var a = 3;
  function bar(){
    console.log(a);
  }
  return bar;
}
var baz = foo();
baz(); // the value of a i.e 3 will appear on console

If you know langauges like C, C++... Your brain would be interpreting this code like this. If you don't know any of them just ignore thiese points.

When foo() is called, variable a will be declared and assigned value 3.
When foo is returned the stack containing a will be destroyed. And hence a would be destroyed too.
Then how in the world baz() is outputting 3. ???

Well, in javascript when a function is called the things that happen are different than in C. So, first let your all C things go out from your mind before reading further.

In javascript scope resolution is done by travelling down a chain of objects that defines variables that are "in scope" for that code. Let's see how?

When you declare a global JavaScript variable, what you are actually doing is defining a property of the global object.
In top-level JavaScript code (i.e., code not contained within any function definitions), the scope chain consists of a single object, the global object.
In a non-nested function, the scope chain consists of two objects. The first is the object that defines the function’s parameters and local variables, and the second is the global object.
In a nested function, the scope chain has three or more objects. When a function is defined, it stores the scope chain then in effect. When that function is invoked, it creates a new object to store its local variables, and adds that new object to the stored scope chain to create a new, longer, chain that represents the scope for that function invocation.

So, when foo() is executed. It creates a new object to store it's local variables. So, variable a will be stored in that object. And also, bar is defined. When bar is defined it stores the scope chain in effect. So, the scope chain of bar now contains the object that has variable a in it. So, when bar is returned it has a reference to it's scope chain. And hence it knows a.

So, I guess it answers your question how node handles the code.

You wrote:

loadOrInitializeTaskArray takes two arguments and the second one is the callback function which shouldn't accept any parameters according to is signature but it does!!

The callback function is

function(tasks) {
    for(var i in tasks) {
      console.log(tasks[i]);
    }
}

And it accepts an argument tasks. So, you are wrong here.

And When loadOrIntializeTaskArray is called cb refers to this call back function. And cb(arg) basically does this tasks = arg where tasks is the argument in callback function.

I guess you still will be having a lot of questions. Let me know in comments. And I highly recommend you to go through the Core Javascript before diving into node.

Thank you Vishal for the effort you put on this comment. I didn't realized my lack of innate knowledge of Javascript has this much of effect on the learning of node.js. I did some client side javascript long time ago and I thought I should be fine. Can you refer me to a intermediate/advanced javascript guide specially on topics like scoping, closure ... ? And you are right, coming from java language, coding in node is confusing specifically with its async callback model.
Yeah sure... I love this book JavaScript: The Definitive Guide. It really is an awesome source both for core & client side javascript. To get started with node you just have to read core javascript.

gruntledcustomer · Accepted Answer · 2014-12-10 04:22:09Z

0

First, there is not really any such thing as a function signature in javascript. You can pass as many or as few arguments to a function as you like. The second argument to loadOrInitialiseTaskArray is simply assigned to the local variable cb when the function is called. The line cb(tasks) then invokes this value, so the second argument had better have been a function.

When you call loadOrInitializeTaskArray from listTasks, the second argument is indeed a function, and the first argument to this function is named tasks in its own scope. It isn't reaching into loadOrInitializeTaskArray and using the variable declared in that function's scope. You explicitly passed in that value when you invoked cb.

The code would work the same and perhaps be easier to understand if we renamed the variables:

function loadOrInitializeTaskArray(file, cb) {
  fs.exists(file, function(exists) {
    var taskArray = [];
    if (exists) {
      fs.readFile(file, 'utf8', function(err, data) {
        if (err) throw err;
        var data = data.toString();
        var taskArray = JSON.parse(data || '[]');
        cb(taskArray);
      });
    } else {
      cb([]); 
    }
  });
}

function listTasks(file) {
  loadOrInitializeTaskArray(file, function(listOfTasks) {
    for(var i in listOfTasks) {
      console.log(listOfTasks[i]);
    }
  });
}

answered Dec 10, 2014 at 4:22

gruntledcustomer

2531 silver badge5 bronze badges

1 Comment

Reza Over a year ago

Thank you for your prompt response. Yes I don't have much experience in Javascript too. As a side question, don't you think if we rewrite these two function in one, it would be easier to understand?

mscdex · Accepted Answer · 2014-12-10 04:27:01Z

0

I'm not sure what you mean by "the second one is the callback function which shouldn't accept any parameters according to is signature". The callback signature (function(tasks)) certainly does expect an argument (tasks).

cb is the callback function that was passed in. In this case it is literally the anonymous function:

function(tasks) {
  for(var i in tasks) {
    console.log(tasks[i]);
  }
}

tasks is the name of two different variables (but they point to the same object because arrays are passed by reference) in different scopes. One is defined in loadOrInitializeTaskArray() as you noted, the other is a parameter for the callback passed to loadOrInitializeTaskArray().

Also, on an unrelated note, typically callbacks follow the "error-first" format. This allows for handling of errors upstream. Modifying the code to follow this convention would result in:

function loadOrInitializeTaskArray(file, cb) {
  fs.exists(file, function(exists) {
    var tasks = [];
    if (exists) {
      fs.readFile(file, 'utf8', function(err, data) {
        if (err)
          return cb(err);

        var data = data.toString();

        // JSON.parse() throws errors/exceptions on parse errors
        try {
          var tasks = JSON.parse(data || '[]');
        } catch (ex) {
          return cb(ex);
        }

        cb(null, tasks);
      });
    } else {
      cb(null, []); 
    }
  });
}

function listTasks(file) {
  loadOrInitializeTaskArray(file, function(err, tasks) {
    if (err) throw err;
    for (var i in tasks) {
      console.log(tasks[i]);
    }
  });
}

edited Dec 10, 2014 at 4:27

answered Dec 10, 2014 at 4:21

mscdex

107k15 gold badges201 silver badges159 bronze badges

2 Comments

Reza Over a year ago

mscdex, Thank you for your response. My knowledge on javascript is not that deep. Coming from C++, Java language, when we define a function like function loadOrInitializeTaskArray(file, cb) can not call it like loadOrInitializeTaskArray(file, function(TASKS)) with an array argument. But of course, this code is in Javascript!

mscdex Over a year ago

The use of inline anonymous functions like that are common. You could pull the function out, give it a name, and then pass in the same function by name instead of the function literal. You might want to check out the MDN JavaScript Guide to become more familiar with the language and its differences from Java/C++.

Collectives™ on Stack Overflow

Node.js calling a callback function inside a callback

3 Answers 3

2 Comments

1 Comment

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

1 Comment

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related