The document discusses various methods from the async module in Node.js for controlling asynchronous callback flow, including: 1) Executing tasks in series or parallel, cascading tasks together, queuing tasks with concurrency control, iterating over arrays, mapping arrays, and reducing arrays. 2) Additional methods for filtering arrays based on an async truth test, and detecting the first value in an array that passes an async truth test. 3) Examples are provided for each method demonstrating how to use the async module to control asynchronous control flow in Node.js applications.

1. Controlling the Callback Flow
Jason
NodeJs

2. Controlling the Callback Flow
● Understanding the boomerang effect
● Using async to control callback flow
Executing in Series
Executing in Parallel
Cascading
Queuing
Iterating
Mapping
Reducing

3. A demonstration of the boomerang effect.
var fs = require('fs');
function append_some_a_to_b(callback) {
fs.open(__dirname + '/a.txt', 'r', function(err, aFd) {
var buffer = new Buffer(10);
fs.read(aFd, buffer, 0, buffer.length, 0, function(err) {
fs.close(aFd, function(err) {
fs.open(__dirname + '/b.txt', 'a', function(err, bFd) {
fs.fstat(bFd, function(err, bStats) {
fs.write(bFd, buffer, 0, buffer.length, bStats.size,
function(err) {
fs.close(bFd, callback);
});
});
});
});
});
});
}

4. Using async to control callback flow
● To install async you include it in your package.json manifest or simply install
it
on your application root directory like this:
> npm install async
● The async module comes with a series of helper functions that allow you to
perform asynchronous iteration and flow control.

5. Executing in Series
series(tasks, [callback])
● Run the functions in the tasks array in series, each one running once the previous function has
completed.
● If any functions in the series pass an error to its callback, no more functions are run, and callback
is immediately called with the value of the error
● tasks - An array or object containing functions to run, each function is passed a callback(err,
result) it must call on completion with an error err (which can be null) and an optional result value
● callback - Callback receives an array of results when tasks have completed.

6. Executing in Series
var async = require('async');
async.series([
function(callback){
callback(null, 'one');
},
function(callback){
callback(null, 'two');
}
],
function(err, results){
if (err) { throw err; }
console.log('results: %j', results); // results is now equal to ['one', 'two']
});

7. Executing in Series
var async = require('async');
async.series({
one: function(callback){
setTimeout(function(){ callback(null, 1); }, 200);
},
two: function(callback){
setTimeout(function(){ callback(null, 2); }, 100);
}
},
function(err, results) {
if (err) { throw err; }
console.log('results: %j', results); // results is now equal to: {one: 1, two: 2}
});

8. Executing in Parallel
parallel(tasks, [callback])
● Run the tasks array of functions in parallel, without waiting until the previous function has
completed
● If any functions in the series pass an error to its callback, no more functions are run, and callback
is immediately called with the value of the error
● tasks - An array or object containing functions to run. Each function is passed a callback(err,
result) which it must call on completion with an error err (which can be null) and an optional result
value.
● callback(err, results) - An optional callback to run once all the functions have completed. This
function gets a results array (or object) containing all the result arguments passed to the task

9. Executing in Parallel
var async = require('async');
async.parallel([
function(callback){
setTimeout(function(){ callback(null, 'one'); }, 200);
},
function(callback){
setTimeout(function(){ callback(null, 'two'); }, 100);
}
],
function(err, results) {
if (err) { throw err; }
console.log('results: %j', results); // results is now equal to: {one: 1, two: 2}
});

10. Executing in Parallel
var async = require('async');
async.parallel({
one: function(callback){
setTimeout(function(){ callback(null, 1); }, 200);
},
two: function(callback){
setTimeout(function(){ callback(null, 2); }, 100);
}
},
function(err, results) {
if (err) { throw err; }
console.log('results: %j', results); // results is now equal to: {one: 1, two: 2}
});

11. Cascading
waterfall(tasks, [callback])
● Runs the tasks array of functions in series, each passing their results to the next in the array.
● If any of the tasks pass an error to their own callback, the next function is not executed, and the
main callback is immediately called with the error.
● tasks - An array of functions to run, each function is passed a callback(err, result1, result2, ...) it
must call on completion. The first argument is an error (which can be null) and any further
arguments will be passed as arguments in order to the next task.
● callback(err, [results]) - An optional callback to run once all the functions have completed. This will
be passed the results of the last task's callback.

12. Cascading
var async = require('async');
async.waterfall([
function(callback){
callback(null, 'one', 'two');
},
function(arg1, arg2, callback){
callback(null, 'three');
},
function(arg1, callback){
callback(null, 'done');
}
], function (err, result) {
console.log('result : ', result);
});

13. Queuing
queue(worker, concurrency)
● If you need to perform some repetitive asynchronous jobs and you want to control the
concurrency
● worker(task, callback) - An asynchronous function for processing a queued task, which must call
its callback(err) argument when finished, with an optional error as an argument.
● concurrency - An integer for determining how many worker functions should be run in parallel.

14. Queuing
var async = require('async');
var q = async.queue(function (task, callback) {
console.log('hello ' + task.name);
callback();
}, 2);
q.drain = function() { console.log('all items have been processed'); }
q.push( {name: 'foo'}, function (err) { console.log('finished processing foo'); });
q.push( {name: 'bar'}, function (err) { console.log('finished processing bar'); });
q.push( [{name: 'baz'},{name: 'bay'},{name: 'bax'}] , function (err) { console.log('finished processing item'); });
q.unshift( {name: 'bar'}, function (err) { console.log('finished processing bar'); });

15. Iterating
forEach(arr, iterator, callback)
● If you use this async.forEach function, you are invoking an iterator for each element in parallel
● iterator(item, callback) - A function to apply to each item in arr.
● callback(results) - A callback which is called when all iterator functions have finished, or an
error occurs.

16. Iterating
var async = require('async');
var results = {};
function iterator(value, callback) {
results[value] = Math.pow(value, 2);
callback();
}
async.forEach([1, 2, 3, 4], iterator, function(err){
if (err) { throw err; }
console.log('results: %j', results);
});
Output :
results: {“1”: 1, “2” : 4, “3” : 9, “4” : 16}

17. Mapping
map(arr, iterator, callback)
● Produces a new array of values by mapping each value in arr through the iterator function
● iterator(item, callback) - A function to apply to each item in arr. The iterator is passed a
callback(err, transformed) which must be called once it has completed with an error (which can be
null) and a transformed item.
● callback(err, results) - A callback which is called when all iterator functions have finished, or an
error occurs. Results is an array of the transformed items from the arr.

18. Mapping
var async = require('async');
function iterator(value, callback) {
callback(null, Math.pow(value, 2));
}
async.map([1, 2, 3, 4], iterator, function(err, results) {
if (err) {
throw err;
}
console.log('results: %j', results);
});
Output : results : [1,4,9,16]

19. Reducing
reduce(arr, memo, iterator, callback)
● Reduces array into a single value using an async iterator to return each successive step.
● memo - The initial state of the reduction.
● iterator(memo, item, callback) - A function applied to each item in the array to produce the next
step in the reduction. The iterator is passed a callback(err, reduction) which accepts an optional
error as its first argument, and the state of the reduction as the second.
● callback(err, result) - A callback which is called after all the iterator functions have finished. Result
is the reduced value.

20. Reducing
var async = require('async');
async.reduce([1,2,3], 0, function(memo, item, callback){
console.log(‘memo:‘ + memo, ‘item:’ + item);
callback(null, memo + item);
}, function(err, result){
console.log('Result : %j', result);
});
Output :
memo : 0 item : 1
memo : 1 item : 2
memo : 3 item : 3
Result : 6

21. Filtering
filter(arr, iterator, callback)
● Returns a new array of all the values in array which pass an async truth test.
● The callback for each iterator call only accepts a single argument of true or false
● It does not accept an error argument first!

22. Filtering
var async = require('async');
function filter(item, callback) {
callback(Math.pow(item, 2) > 10);
}
async.filter([1, 2, 3, 4, 5], filter, function(results)
{
console.log('Square value is greater than 10: %j', results);
});
Output : Square value is greater than 10: [4,5]

23. Filtering
var async = require('async');
var fs = require(‘fs’);
async.filter(['file1','file2','file3'], fs.exists, function(results){
// results now equals an array of the existing files
});

24. Detecting
detect(arr, iterator, callback)
● Returns the first value in array that passes an async truth test.
● The iterator is applied in parallel, meaning the first iterator to return true will fire the detect callback
with that result

25. Detecting
var async = require('async');
function filter(item, callback) {
callback(Math.pow(item, 2) > 10);
}
async.detect([1, 2, 3, 4, 5], filter, function(result)
{
console.log('Square value is greater than 10: %j', result);
});
Output : Square value is greater than 10: 4

26. Detecting
var async = require('async');
var fs = require(‘fs’);
async.detect(['file1','file2','file3'], fs.exists, function(results){
console.log("exist : ", result);
});