node.js and asynchronous programming palindrome

Question

node.js and asynchronous programming palindrome

This question might be possible duplication. I am a noob to node.js and asynchronous programming palindrome. I have google searched and seen a lot of examples on this, but I still have bit confusion.

OK, from google search what I understand is that all the callbacks are handled asynchronous. for example, let's take readfile function from node.js api

fs.readFile(filename, [options], callback) // callback here will be handled asynchronously fs.readFileSync(filename, [options])

  var fs = require('fs');

    fs.readFile('async-try.js' ,'utf8' ,function(err,data){
        console.log(data);   })

    console.log("hii");

The above code will first print hii then it will print the content of the file.

So, my questions are:

Are all callbacks handled asynchronously?

The below code is not asynchronous, why and how do I make it?

function compute(callback){
 for(var i =0; i < 1000 ; i++){}
 callback(i);

}

function print(num){
 console.log("value of i is:" + num);
}


compute(print);
console.log("hii");

javascript
node.js
asynchronous

Answer 1

Are all callbacks handled asynchronously?

Not necessarily. Generally, they are, because in NodeJS their very goal is to resume execution of a function (a continuation) after a long running task finishes (typically, IO operations). However, you wrote yourself a synchronous callback, so as you can see they're not always asynchronous.

The below code is not asynchronous, why and how do I make it?

If you want your callback to be called asynchronously, you have to tell Node to execute it "when it has time to do so". In other words, you defer execution of your callback for later, when Node will have finished the ongoing execution.

function compute(callback){
 for (var i = 0; i < 1000; i++);

 // Defer execution for later
 process.nextTick(function () { callback(i); });
}

Output:

hii
value of i is:1000

For more information on how asynchronous callbacks work, please read this blog post that explains how process.nextTick works.

Answer 2

No, that is a regular function call.

A callback will not be asynchronous unless it is forced to be. A good way to do this is by calling it within a setTimeout of 0 milliseconds, e.g.

setTimeout(function() { 
   // Am now asynchronous
}, 0);

Generally callbacks are made asynchronous when the calling function involves making a new request on the server (e.g. Opening a new file) and it doesn't make sense to halt execution whilst waiting for it to complete.

Answer 3

The below code is not asynchronous, why and how do I make it?

function compute(callback){
  for(var i =0; i < 1000 ; i++){}
  callback(i);
}

I'm going to assume your code is trying to say, "I need to do something 1000 times then use my callback when everything is complete".

Even your for loop won't work here, because imagine this:

function compute(callback){
  for(var i =0; i < 1000 ; i++){
    DatabaseModel.save( function (err, result) {
      // ^^^^^^ or whatever, Some async function here.
      console.log("I am called when the record is saved!!");
    });
  }
  callback(i);
}

In this case your for loop will execute the save calls, not wait around for them to be completed. So, in your example, you may get output like (depending on timing)

I am called when the record is saved
hii
I am called when the record is saved
...

For your compute method to only call the callback when everything is truely complete - all 1000 records have been saved in the database - I would look into the async Node package, which can do this easily for you, and provide patterns for many async problems you'll face in Node.

So, you could rewrite your compute function to be like:

function compute(callback){
  var count = 0
  async.whilst(
     function() { return count < 1000 },
     function(callback_for_async_module) {
        DatabaseModel.save( function (err, result) {
            console.log("I am called when the record is saved!!");
            callback_for_async_module();
            count++;
        });
     },
     function(err) {
       // this method is called when callback_for_async_module has
       // been called 1000 times

       callback(count);
  );
  console.log("Out of compute method!");
}

Note that your compute function's callback parameter will get called sometime after console.log("Out of compute method"). This function is now asynchronous: the rest of the application does not wait around for compute to complete.

Answer 4

You can put every callback call inside a timeout with one milisecond, that way they will be executed first when there are a thread free and all synchron tasks are done, then will the processor work through the stack of timeouts that want to be executet.