Results of tasks in async.auto

Question

I am kind of confused with the logic of results which go from one task to the other task in async.auto. For example in the following code logic I added some data to models in task1, which is initially an output from initialtask and in finalTask added data to models from task1 is reflected in results.initialTask1 as well. Similarly added data in task2 is reflected in results.initialTask1 in finalTask.

To sum up all of results.initialTask1, results.task1[0], results.task2[0], results.task3[0] are identical in finalTask. Is this the logic of async.auto? Or is it something like reference by pointer in C++ which causes whatever changes for models in task1, it reflects in models in initialTask as well?

async.auto({
    initialTask: function(callback) {
        //Do some operations
        callback(null, name, initialModels);
    },
    task1: ['initialTask', function(callback, results) {
        var models = results.initialTask[1];
        //Add some more data to models
        callback(null, models);
    }],
    task2: ['initialTask', function(callback, results) {
        var models = results.initialTask[1];
        //Add some more data to models
        callback(null, models);
    }],
    task3: ['initialTask', function(callback, results) {
        var models = results.initialTask[1];
        //Add some more data to models
        callback(null, models);
    }],
    finalTask: ['task1', 'task2', 'task3', function(callback, results) {
        //Here the followings are the same: results.initialTask[1], results.task1[0], results.task2[0], results.task3[0]                               
    }]
});

I'm looking for any answer which helps me make sure that is the logic or not? I'm not necessarily looking for any official documents or ...

Answer 1

This is expected behavior. Basically async.auto will execute all the functions in the order it deems necessary. So in your case initialTask will be called first. Then task1, task2, and task3 will be called in parallel. Finally finalTask will be called with the results. The reason all the values are the same is related to JavaScript's call-by-sharing, meaning if you change a function parameter itself, then it won't affect the item that was fed into the parameter. If you change the internals of the parameter, it will carry up to the item.

More info here.

Example:

async.auto({
// this function will just be passed a callback
readData: async.apply(fs.readFile, 'data.txt', 'utf-8'),
showData: ['readData', function(results, cb) {
    // results.readData is the file's contents
    // ...
}]
}, callback);

async.auto({
get_data: function(callback) {
    console.log('in get_data');
    // async code to get some data
    callback(null, 'data', 'converted to array');
},
make_folder: function(callback) {
    console.log('in make_folder');
    // async code to create a directory to store a file in
    // this is run at the same time as getting the data
    callback(null, 'folder');
},
write_file: ['get_data', 'make_folder', function(results, callback) {
    console.log('in write_file', JSON.stringify(results));
    // once there is some data and the directory exists,
    // write the data to a file in the directory
    callback(null, 'filename');
}],
email_link: ['write_file', function(results, callback) {
    console.log('in email_link', JSON.stringify(results));
    // once the file is written let's email a link to it...
    // results.write_file contains the filename returned by write_file.
    callback(null, {'file':results.write_file, 
'email':'user@example.com'});
}]
}, function(err, results) {
console.log('err = ', err);
console.log('results = ', results);
});

Answer 2

async.auto is very useful and powerful function which is provided by Async Lib .it have 3 fields 1-task 2- concurrency 3-callback

In Async.auto, Each function depends on its parent function except the first function, if any function will get any error during execution .then their child function or say .. their below-defined function will not get executed further, an error will occur with callback and the main callback will immediately return with an error

1- Task :- an Object 2- concurrency :- An optional integer for determining the maximum number of tasks that can be run in parallel. By default, as many as possible. 3- callback:- return the response

exapmle-

 AnyService.prototype.forgetPassword = function (res, email, isMobile, callback) {
    Logger.info("In AnyService service forgetPassword email...", email);
    db.User.findOne({
        email: email.toLowerCase(),
        deleted: false
    }, function (err, user) {
        if (!user) {
            configurationHolder.responseHandler(res, null, configurationHolder.LoginMessage.registerFirst, true, 403)
        } else {
            async.auto({
                token: function (next, results) {
                    return gereratePasswordToken(next, email, user, isMobile);
                },
                sendMail: ['token', function (next, result) {
                    return SendMailService.prototype.forgetPasswordMail(next, result.token, email, user.fullName);
                  }]
            }, function (err, result) {
                if (err == null && result != null) {
                    configurationHolder.ResponseUtil.responseHandler(res, null,      configurationHolder.LoginMessage.forgotPassword, false, 200)
                } else {
                    callback(new Error(configurationHolder.errorMessage.oops))
                }
            })
        }
    });
  }