promise-async

The async-module is a very useful module for
doing a set of asynchronous operations in a specified order. The async-module
expects all functions to take a callback as the last parameter. This module
tries to provide the same API and functionality as the async-module using
promises instead of callbacks.

Currently only a small subset of the async-api is implemented. Please send
pull-requests for other methods.

installation

npm install async-p

parallel, parallelLimit, and series

These functions take an array of jobs as the first parameter. A job is a
function that returns a promise.

var async = require('async-p')

function job() {
return new Promise(function(resolve) {
setTimeout(resolve, 1000)
})
}

$3

Run all jobs in parallel. Returns a promise that resolves when the promises
returned by all jobs have resolved.

async.parallel([job, job, job])
.then( function() {
console.log('All jobs resolved in parallel')
})
.catch( function(err) {
// At least one job rejected and its reject was called with err
})

parallel is the same as Promise.all()

$3

Run jobs in parallel with a limit on how many jobs can run in parallel. Returns
a promise that resolves when the promises returned by all jobs have resolved.

async.parallelLimit([job, job, job],2)
.then( function() {
console.log('All jobs resolved, max 2 running at a time')
})
.catch( function(err) {
// At least one job rejected and its reject was called with err
})

$3

Run jobs in series. Equal to parallelLimit(jobs, 1). Returns a promise that
resolves when the promises returned by all jobs have resolved.

async.series([job, job, job])

each, eachLimit, eachSeries

The each-functions take as arguments an array and a process-function that takes
one item from the array and returns a promise. Returns a promise that resolves
when the process-function has been run with all items from the array and all the
returned promises have been resolved. The process-function is guaranteed to be
applied to the items in the array in order.

var async = require('async-p')

function process(item) {
return new Promise(function(resolve) {
console.log(item)
setTimeout(resolve, 1000)
})
}

$3

Process all items in the array in parallel. Returns a promise that resolves when
the promises returned by all process-invocations have resolved.

async.each([1,2,3], process)
.then( function() {
console.log('Done')
})
.catch( function(err) {
// At least one process() rejected and its reject was called with err
})

$3

Process all items in the array in parallel with a limit on how many items can be
processed in parallel. Returns a promise that resolves when the promises
returned by all process-invocations have resolved.

async.parallelLimit([1,2,3], process, 2)
.then( function() {
console.log('All items processed, max 2 running at a time')
})
.catch( function(err) {
// At least one process-call rejected and its reject was called with err
})

$3

Process all items in series. Equal to eachLimit(jobs, 1). Returns a promise that
resolves when the promises returned by all process-invocations have resolved.

async.eachSeries([1,2,3], process)