node.js async.series is that how it is supposed to

Question

var async = require('async');

function callbackhandler(err, results) {
    console.log('It came back with this ' + results);
}   

function takes5Seconds(callback) {
    console.log('Starting 5 second task');
    setTimeout( function() { 
        console.log('Just finshed 5 seconds');
        callback(null, 'five');
    }, 5000);
}   

function takes2Seconds(callback) {
    console.log('Starting 2 second task');
    setTimeout( function() { 
        console.log('Just finshed 2 seconds');
        callback(null, 'two');
    }, 2000); 
}   

async.series([takes2Seconds(callbackhandler), 
              takes5Seconds(callbackhandler)], function(err, results){
    console.log('Result of the whole run is ' + results);
}) 

The output looks like below :

Starting 2 second task
Starting 5 second task
Just finshed 2 seconds
It came back with this two
Just finshed 5 seconds
It came back with this five

I was expecting the takes2Second function to finish completely before the takes5Second starts. Is that how it is supposed to work. Please let me know. And the final function never runs. Thanks.

Answer 1

Not quite. You are executing the functions immediately (as soon as the array is evaluated), which is why they appear to start at the same time.

The callback passed to each of the functions to be executed is internal to the async library. You execute it once your function has completed, passing an error and/or a value. You don't need to define that function yourself.

The final function never runs in your case because the callback function that async needs you to invoke to move on to the next function in the series never actually gets executed (only your callbackHandler function gets executed).

Try this instead:

async.series([
    takes2Seconds,
    takes5seconds
], function (err, results) {
    // Here, results is an array of the value from each function
    console.log(results); // outputs: ['two', 'five']
});

Answer 2

My preferred way to create the async series is using operational array as follow;

var async = require('async'),
    operations = [];

operations.push(takes2Seconds);
operations.push(takes5seconds);

async.series(operations, function (err, results) {
    // results[1]
    // results[2]
});

function takes2Seconds(callback) {
    callback(null, results);
}

function takes5seconds(callback) {
    callback(null, results);
}

Answer 3

In async.series,all the functions are executed in series and the consolidated outputs of each function is passed to the final callback. e.g

var async = require('async');
async.series([
    function (callback) {
        console.log('First Execute..');
        callback(null, 'userPersonalData');
    },
    function (callback) {
        console.log('Second Execute.. ');
        callback(null, 'userDependentData');
    }
],
function (err, result) {
    console.log(result);
});

Output:

First Execute..
Second Execute..
['userPersonalData','userDependentData'] //result

Answer 4

async.series
    ([  
        function (callback)
        {
            response=wsCall.post(user,url,method,response);
            console.log("one");
            callback();
        }
        ,
        function (callback)
        {
            console.log("two");
            //console.log(response);
            callback();
        }
    ]
    ,
    function(err) 
    {
        console.log('Both a and b are saved now');
        console.log(response);
    });

Answer 5

James gave you a good overview of async.series. Note that you can setup anonymous functions in the series array and then call your actual functions with parameters

var async = require('async')
var param1 = 'foobar'
function withParams(param1, callback) {
  console.log('withParams function called')
  console.log(param1)
  callback()
}
function withoutParams(callback) {
  console.log('withoutParams function called')
  callback()
}
async.series([
  function(callback) {
    withParams(param1, callback)
  },
  withoutParams
], function(err) {
  console.log('all functions complete')
})