I have found two handy modules called run-parallel and run-series to run arrays functions and return arrays of results.
Looking at the little number of contributors and stars in the Github projects, I wonder if there is a canonical way of doing these tasks instead of installing these modules?
Maybe there is a native way in Node or in ES6 to do this that I am missing?
First see some examples - scroll below for an explanation.
Example with async and functions that take Node-style callbacks:
async.parallel([
(cb) => {
setTimeout(() => {
cb(null, 'one');
}, 200);
},
(cb) => {
setTimeout(() => {
cb(null, 'two');
}, 100);
},
],
(err, results) => {
if (err) {
// there was an error:
console.log('Error:', err);
return;
}
// we have ['one', 'two'] in results:
console.log('Results:', JSON.stringify(results));
});
Example using functions that return promises - with Bluebird's delay() function:
const { delay } = require('bluebird');
Promise.all([
delay(200, 'one'),
delay(100, 'two'),
]).then((results) => {
// we have ['one', 'two'] in results:
console.log('Results:', JSON.stringify(results));
}).catch((err) => {
// there was an error:
console.log('Error:', err);
});
async/await:Using async/await:
const { delay } = require('bluebird');
try {
const results = await Promise.all([
delay(200, 'one'),
delay(100, 'two'),
]);
// we have ['one', 'two'] in results:
console.log('Results:', JSON.stringify(results));
} catch (err) {
// there was an error:
console.log('Error:', err);
}
I'm using JSON.stringify() to make it explicit what is the format of the data in results.
Note that even though the first value comes last, the original order is still preserved.
The last example must be run inside of a function declared with an async keyword, or wrapped in (async () => { ... })() like this:
(async () => {
try {
const results = await Promise.all([
delay(200, 'one'),
delay(100, 'two'),
]);
// we have ['one', 'two'] in results:
console.log('Results:', JSON.stringify(results));
} catch (err) {
// there was an error:
console.log('Error:', err);
}
})();
With no support for async/await you can use some generator-based coroutines, like those that comes from Bluebird:
const { delay, coroutine } = require('bluebird');
coroutine(function* () {
try {
const results = yield Promise.all([
delay(200, 'one'),
delay(100, 'two'),
]);
// we have ['one', 'two'] in results:
console.log('Results:', JSON.stringify(results));
} catch (err) {
// there was an error:
console.log('Error:', err);
}
})();
There are many ways to do that and it all depends on the kind of functions that you want to run.
If you want to run a traditional Node-style functions that take error-first callbacks as their last arguments then the most popular way to run those in parallel or in series is the async module on npm:
There is no built-in support for things like that in ES6 because those error-first callbacks are really a Node thing, not very popular in JavaScript outside of Node.
The ES6/ES7/ES8 goes in the direction of functions that return promises (instead of functions that take callbacks) and there is a new async/await syntax to make them look kind-of-like synchronous, with try/catch working for error handling.
So, the most popular way in Node to combine functions taking callbacks is async module:
To work with promises a popular modules is Bluebird:
For more advanced tasks there is Task.js:
See those answers for more info:
Remember that functions can just be passed around like any other object in JavaScript, so it's actually pretty straightforward to do things like this.
For example, to run things in series you could just use map to generate an array of results by executing each of your functions - like this...
let functions = [
function() { return 'abc'; },
function() { return 123; },
function() { return { key: 'value' }; }
];
let results = functions.map(fn => fn());
Obviously, what you get from using these libraries is nice - hopefully well tested - handling for when things go wrong etc. but it's perfectly possible to do it without them.
You can use Array.prototype.map() to loop through all functions in your array sequentially, using an anonymous function that executes each function in the array as a parameter.
Using Function.prototype.apply() instead of directly calling the function allows you to pass an array to each function with its parameters.
var functions = [
function(x){return 3 * x},
function(x){return 4 * x},
function(x){return 8 * x},
function(x){return 10 * x},
function(){return Array.prototype.map.call(arguments, function(name){
return "Hello, " + name
})}
];
var results = functions.map(function(value, index) {
return value.apply(value, this[index]);
}, [[5], [1], [8], [8], ["Dolly", "major Tom"]]);
document.body.innerHTML = '<pre>' + JSON.stringify(results, null, '\t') + '</pre>';See also this Fiddle.
The structure depends on what you want to implement. :D
functions = {};
async function getArticle(id = 0) {
// const result = await articles.get(id); get result of a db.
const result = { id: 10, name: "apple" }
if (result) return result;
return false;
}
async function validatePermission(id = 0) {
// const result = await users.get(id); get result of a db.
const result = { id: 25 }
if (result) return result;
return false;
}
functions.getArticle = async params => {
const { userId, articleId } = params;
const [validUser, article] = await Promise.all([
validatePermission(userId),
getArticle(articleId),
]);
if (validUser === false || article === false) {
return { status: 400, message: 'Error', data: [] }
}
return { status: 200, message: 'Success', data: article };
}
const params = { userId: 25, articleId: 10 };
functions.getArticle(params)
.then(result => {
console.log(result);
});