ParallelArrayRunner
A promise enabled, ES6 Class for executing an asynchronous function in parallel, for each element in a supplied array.
Synopsis
Execute statements in parallel, throwing away any resolved data (such as database inserts):
let ParallelArrayRunner = require('parallel-array-runner');let s = new ParallelArrayRunner(ParallelArrayRunner.LAST_RETURN);s.run(arrayToIterate, functionToCall, scope, dbConnection) .then( (results) => { // Used this way, results contains the data from the last function call. // If all function calls resolve, we get here. Otherwise, rejected. // For each element in the array the function call would look like: // functionToCall(element, dbConnection); });
Capture all resolved data in an array and return it with the resolved promise:
let s = ParallelArrayRunnerARRAY_RETURN;s
Expect array data from the given function and concatenate into an results array:
let s = ParallelArrayRunnerCONCAT_ARRAY_RETURN;s
Change the behavior of the class at any time with behaviorType setter:
let s = ; // Default behavior is LAST_RETURNsbehaviorType = ParallelArrayRunnerARRAY_RETURN;
Description
The purpose of this class is to provide an easy mechanism for applying array data to promise enabled asynchronous functions (or class methods). This class by itself is less useful then it's sister classes (SerializedArrayRunner and HybridArrayRunner) in that the same strategy can be accomplished with Promise.all(). However, it provides a common run interface as the aforementioned sister classes and is used internally in HybridArrayRunner.
In simpler terms:
- I have an array of something.
- I want to call an asynchronous function in parallel (returning a promise) to operate on each item in the array.
- I want a promise returned when all of the the function promises have been resolved.
- I may or may not want to capture all of the returned data from each function call.
Project Features
- ES6 Class
- Promise enabled
- Complete test coverage with Mocha and Chai
- JSDoc generated API documentation
- Rest parameters are used for maximum flexibility.
Installation
npm install parallel-array-runner --save
Git Repository: https://github.com/wildbillh/parallel-array-runner
Documentation
API Documentation: ParallelArrayRunner.html
Example Usage
The code below shows typical use of the class. File example-uses.js is available in the example folder, but is included below as a convenience.
// File: example-uses.js "use strict"; let ParallelArrayRunner = ; // Create some simulated async calls that return promises // This function takes 2 numbers as parameters and returns a promise of their sums.let { return { ; };}; // This function takes 3 parameters and returns a promise of a 3 element array.let { return { ; };}; let { return { ; };}; let runner = null;let scope = null; // The constructor sets the behavior type. Setting an invalid type will throw an exception.// In latter sets, we won't bother with catching the exception.try runner = ;catch err console; process; // For each element in the array [1,2,3], call the addTwoNumbers function.// For each call to the function, the first argument will be the current// element and the second argument will be 10.// Since we didn't set the behavior in the constructor, we get the// default behavior (ParallelArrayRunner.LAST_RETURN)// The run method will return a promise containing the data// from the last call - addTwoNumbers(3,10)// If any of the calls to the function reject, the run method rejects as well. runner ;