JS library to perform operations in parallel
============
This library makes it easy to execute operations in parallel
$ npm install --save polallel
...
import { rxParallel } from 'polallel'
async function asyncOperation(element: any, arg1: string, args2: number): Promise<any> {
...
}
async function example(): Promise<void> {
try {
const listOfArguments = [...Array(20).keys()];
const examples: any[] = await rxParallel(listOfArguments, asyncOperation, 5, 2 ["arg1", 4]);
console.log("examples", examples);
} catch (error) {
console.log(error.message);
}
}
example()
The parallel function is used to call an asynchronous operation for each element of the array with the possibility of indicating the number of concurrent executions and retries for each element.
USAGE
import { parallel } from 'polallel'
async function asyncOperation(element: any, arg1: string, args2: number): Promise<any> {
...
}
async function example(): Promise<void> {
try {
const listOfArguments = [...Array(20).keys()];
const examples: any[] = await parallel(listOfArguments, asyncOperation, 5, 2, ["arg1", 4]);
console.log("examples", examples);
} catch (error) {
console.log(error.message);
}
}
OPTIONS
/**
* @param {T[]} elements
* @param {(element:T,...parameters:any)=>Promise<K>} asyncOperation
* @param {number=10} concurrencyLimit
* @param {number=0} retryLimit
* @param {any[]=[]} parameters
* @returns Promise
*/
The parallelAll function is used to call an asynchronous operation for each element of the array and retries for each element
USAGE
import { parallelAll } from 'polallel'
async function asyncOperation(element: any, arg1: string, args2: number): Promise<any> {
...
}
async function example(): Promise<void> {
try {
const listOfArguments = [...Array(20).keys()];
const examples: any[] = await parallelAll(listOfArguments, asyncOperation, 2, ["arg1", 4]);
console.log("examples", examples);
} catch (error) {
console.log(error.message);
}
}
OPTIONS
/**
* @param {T[]} elements
* @param {(element:T,...parameters:any)=>Promise<K>} asyncOperation
* @param {number=0} retryLimit
* @param {any[]=[]} parameters
* @returns Promise
*/
The parallelBatches function is used to call an asynchronous operation for each element of the batch array
USAGE
import { parallelBatches } from 'polallel'
async function asyncOperation(element: any, arg1: string, args2: number): Promise<any> {
...
}
async function example(): Promise<void> {
try {
const listOfArguments = [...Array(20).keys()];
const examples: any[] = await parallelBatches(listOfArguments, asyncOperation, 5, 2, ["arg1", 4]);
console.log("examples", examples);
} catch (error) {
console.log(error.message);
}
}
OPTIONS
/**
* @param {T[]} elements
* @param {(element:T,...parameters:any)=>Promise<K>} asyncOperation
* @param {number=10} batchesLimit
* @param {number=0} retryLimit
* @param {any[]=[]} parameters
* @returns Promise
*/
The rxParallel function is used to call an asynchronous operation for each element of the array with the possibility of indicating the number of concurrent executions and retries for each element. This function uses reactive extensions and return a Observable
USAGE
import { rxParallel } from 'polallel'
async function asyncOperation(element: any, arg1: string, args2: number): Promise<any> {
...
}
rxParallel(listOfArguments, asyncOperation, 5 , 3, ["arg1", 4]).subscribe(console.log);
OPTIONS
/**
* @param {T[]} elements
* @param {(element:T,...parameters:any)=>Promise<K>} asyncOperation
* @param {number=10} concurrencyLimit
* @param {number=0} retryLimit
* @param {any[]=[]} parameters
* @returns Observable
*/
The rxAsyncParallel function is used to call an asynchronous operation for each element of the array with the possibility of indicating the number of concurrent executions and retries for each element. This function uses reactive extensions
USAGE
import { rxAsyncParallel } from 'polallel'
async function asyncOperation(element: any, arg1: string, args2: number): Promise<any> {
...
}
async function example(): Promise<void> {
try {
const listOfArguments = [...Array(20).keys()];
const examples: any[] = await rxAsyncParallel(listOfArguments, asyncOperation, 5, 2, ["arg1", 4]);
console.log("examples", examples);
} catch (error) {
console.log(error.message);
}
}
OPTIONS
/**
* @param {T[]} elements
* @param {(element:T,...parameters:any)=>Promise<K>} asyncOperation
* @param {number=10} concurrencyLimit
* @param {number=0} retryLimit
* @param {any[]=[]} parameters
* @returns Promise
*/
The rxAsyncParallelAll function is used to call an asynchronous operation for each element of the array and retrieves for each element. This function uses reactive extensions
USAGE
import { rxAsyncParallelAll } from 'polallel'
async function asyncOperation(element: any, arg1: string, args2: number): Promise<any> {
...
}
async function example(): Promise<void> {
try {
const listOfArguments = [...Array(20).keys()];
const examples: any[] = await rxAsyncParallelAll(listOfArguments, asyncOperation, 2, ["arg1", 4]);
console.log("examples", examples);
} catch (error) {
console.log(error.message);
}
}
OPTIONS
/**
* @param {T[]} elements
* @param {(element:T,...parameters:any)=>Promise<K>} asyncOperation
* @param {number=0} retryLimit
* @param {any[]=[]} parameters
* @returns Promise
*/
Can be imported directly from the function type to exclude native or reactive
USAGE
// rxParallel use reactive extensions
import { rxParallel } from 'polallel/lib/reactive'
// import native functions with promises
import { parallel, parallelAll, parallelBatches } from 'polallel/lib/native'
There are other helper functions to retry asynchronous functions or synchronous functions
- retryPromise
- retryFunction
USAGE
import { retryPromise } from 'polallel'
There are other helper functions
- parallelAllRequired: all executions in parallel must be successful otherwise it will fail
- rxAsyncParallelAll: all execution using reactive extension with asynchronous return
- rxAsyncParallel: execution using reactive extension with asynchronous return
USAGE
import { parallelAllRequired } from 'polallel'