Async.js
Async is a utility module which provides straight-forward, powerful functions for working with asynchronous JavaScript. Although originally designed for use with Node.js, it can also be used directly in the browser. Also supports component.
Async provides around 20 functions that include the usual 'functional' suspects (map
, reduce
, filter
, each
…) as well as some common patterns for asynchronous control flow (parallel
, series
, waterfall
…). All these functions assume you follow the Node.js convention of providing a single callback as the last argument of your async
function.
Quick Examples
There are many more functions available so take a look at the docs below for a full list. This module aims to be comprehensive, so if you feel anything is missing please create a GitHub issue for it.
Common Pitfalls
Binding a context to an iterator
This section is really about bind
, not about async
. If you are wondering how to make async
execute your iterators in a given context, or are confused as to why a method of another library isn't working as an iterator, study this example:
Download
The source is available for download from GitHub. Alternatively, you can install using Node Package Manager (npm
):
Development: async.js - 29.6kb Uncompressed
In the Browser
So far it's been tested in IE6, IE7, IE8, FF3.6 and Chrome 5.
Usage:
Documentation
Collections
Control Flow
Utils
Collections
each(arr, iterator, callback)
Applies the function iterator
to each item in arr
, in parallel. The iterator
is called with an item from the list, and a callback for when it has finished. If the iterator
passes an error to its callback
, the main callback
(for the each
function) is immediately called with the error.
Note, that since this function applies iterator
to each item in parallel, there is no guarantee that the iterator functions will complete in order.
Arguments
arr
- An array to iterate over.iterator(item, callback)
- A function to apply to each item inarr
.The iterator is passed a
callback(err)
which must be called once it hascompleted. If no error has occured, the
callback
should be run withoutarguments or with an explicit
null
argument.callback(err)
- A callback which is called when alliterator
functionshave finished, or an error occurs.
Examples
eachSeries(arr, iterator, callback)
The same as each
, only iterator
is applied to each item in arr
in series. The next iterator
is only called once the current one has completed. This means the iterator
functions will complete in order.
eachLimit(arr, limit, iterator, callback)
The same as each
, only no more than limit
iterator
s will be simultaneously running at any time.
Note that the items in arr
are not processed in batches, so there is no guarantee that the first limit
iterator
functions will complete before any others are started.
Arguments
arr
- An array to iterate over.limit
- The maximum number ofiterator
s to run at any time.iterator(item, callback)
- A function to apply to each item inarr
.The iterator is passed a
callback(err)
which must be called once it hascompleted. If no error has occured, the callback should be run without
arguments or with an explicit
null
argument.callback(err)
- A callback which is called when alliterator
functionshave finished, or an error occurs.
Example
map(arr, iterator, callback)
Produces a new array of values by mapping each value in arr
through the iterator
function. The iterator
is called with an item from arr
and a callback for when it has finished processing. Each of these callback takes 2 arguments: an error
, and the transformed item from arr
. If iterator
passes an error to this callback, the main callback
(for the map
function) is immediately called with the error.
Note, that since this function applies the iterator
to each item in parallel, there is no guarantee that the iterator
functions will complete in order. However, the results array will be in the same order as the original arr
.
Arguments
arr
- An array to iterate over.iterator(item, callback)
- A function to apply to each item inarr
.The iterator is passed a
callback(err, transformed)
which must be called onceit has completed with an error (which can be
null
) and a transformed item.callback(err, results)
- A callback which is called when alliterator
functions have finished, or an error occurs. Results is an array of the
transformed items from the
arr
.
Example
mapSeries(arr, iterator, callback)
The same as map
, only the iterator
is applied to each item in arr
in series. The next iterator
is only called once the current one has completed. The results array will be in the same order as the original.
mapLimit(arr, limit, iterator, callback)
The same as map
, only no more than limit
iterator
s will be simultaneously running at any time.
Note that the items are not processed in batches, so there is no guarantee that the first limit
iterator
functions will complete before any others are started.
Arguments
arr
- An array to iterate over.limit
- The maximum number ofiterator
s to run at any time.iterator(item, callback)
- A function to apply to each item inarr
.The iterator is passed a
callback(err, transformed)
which must be called onceit has completed with an error (which can be
null
) and a transformed item.callback(err, results)
- A callback which is called when alliterator
calls have finished, or an error occurs. The result is an array of the
transformed items from the original
arr
.
Example
filter(arr, iterator, callback)
Alias: select
Returns a new array of all the values in arr
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! This is in-line with the way node libraries work with truth tests like fs.exists
. This operation is performed in parallel, but the results array will be in the same order as the original.
Arguments
arr
- An array to iterate over.iterator(item, callback)
- A truth test to apply to each item inarr
.The
iterator
is passed acallback(truthValue)
, which must be called with aboolean argument once it has completed.
callback(results)
- A callback which is called after all theiterator
functions have finished.
Example
filterSeries(arr, iterator, callback)
Alias: selectSeries
The same as filter
only the iterator
is applied to each item in arr
in series. The next iterator
is only called once the current one has completed. The results array will be in the same order as the original.
reject(arr, iterator, callback)
The opposite of filter
. Removes values that pass an async
truth test.
rejectSeries(arr, iterator, callback)
The same as reject
, only the iterator
is applied to each item in arr
in series.
reduce(arr, memo, iterator, callback)
Aliases: inject
, foldl
Reduces arr
into a single value using an async iterator
to return each successive step. memo
is the initial state of the reduction. This function only operates in series.
For performance reasons, it may make sense to split a call to this function into a parallel map, and then use the normal Array.prototype.reduce
on the results. This function is for situations where each step in the reduction needs to be async; if you can get the data before reducing it, then it's probably a good idea to do so.
Arguments
arr
- An array to iterate over.memo
- The initial state of the reduction.iterator(memo, item, callback)
- A function applied to each item in thearray to produce the next step in the reduction. The
iterator
is passed acallback(err, reduction)
which accepts an optional error as its firstargument, and the state of the reduction as the second. If an error is
passed to the callback, the reduction is stopped and the main
callback
isimmediately called with the error.
callback(err, result)
- A callback which is called after all theiterator
functions have finished. Result is the reduced value.
Example
reduceRight(arr, memo, iterator, callback)
Alias: foldr
Same as reduce
, only operates on arr
in reverse order.
detect(arr, iterator, callback)
Returns the first value in arr
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. That means the result might not be the first item in the original arr
(in terms of order) that passes the test.
If order within the original arr
is important, then look at detectSeries
.
Arguments
arr
- An array to iterate over.iterator(item, callback)
- A truth test to apply to each item inarr
.The iterator is passed a
callback(truthValue)
which must be called with aboolean argument once it has completed.
callback(result)
- A callback which is called as soon as any iterator returnstrue
, or after all theiterator
functions have finished. Result will bethe first item in the array that passes the truth test (iterator) or the
value
undefined
if none passed.
Example
detectSeries(arr, iterator, callback)
The same as detect
, only the iterator
is applied to each item in arr
in series. This means the result is always the first in the original arr
(in terms of array order) that passes the truth test.
sortBy(arr, iterator, callback)
Sorts a list by the results of running each arr
value through an async iterator
.
Arguments
arr
- An array to iterate over.iterator(item, callback)
- A function to apply to each item inarr
.The iterator is passed a
callback(err, sortValue)
which must be called once ithas completed with an error (which can be
null
) and a value to use as the sortcriteria.
callback(err, results)
- A callback which is called after all theiterator
functions have finished, or an error occurs. Results is the items from
the original
arr
sorted by the values returned by theiterator
calls.
Example
Sort Order
By modifying the callback parameter the sorting order can be influenced:
some(arr, iterator, callback)
Alias: any
Returns true
if at least one element in the arr
satisfies an async test. The callback for each iterator call only accepts a single argument of true
or false
; it does not accept an error argument first! This is in-line with the way node libraries work with truth tests like fs.exists
. Once any iterator call returns true
, the main callback
is immediately called.
Arguments
arr
- An array to iterate over.iterator(item, callback)
- A truth test to apply to each item in the arrayin parallel. The iterator is passed a callback(truthValue) which must be
called with a boolean argument once it has completed.
callback(result)
- A callback which is called as soon as any iterator returnstrue
, or after all the iterator functions have finished. Result will beeither
true
orfalse
depending on the values of the async tests.
Example
every(arr, iterator, callback)
Alias: all
Returns true
if every element in arr
satisfies an async test. The callback for each iterator
call only accepts a single argument of true
or false
; it does not accept an error argument first! This is in-line with the way node libraries work with truth tests like fs.exists
.
Arguments
arr
- An array to iterate over.iterator(item, callback)
- A truth test to apply to each item in the arrayin parallel. The iterator is passed a callback(truthValue) which must be
called with a boolean argument once it has completed.
callback(result)
- A callback which is called after all theiterator
functions have finished. Result will be either
true
orfalse
depending onthe values of the async tests.
Example
concat(arr, iterator, callback)
Applies iterator
to each item in arr
, concatenating the results. Returns the concatenated list. The iterator
s are called in parallel, and the results are concatenated as they return. There is no guarantee that the results array will be returned in the original order of arr
passed to the iterator
function.
Arguments
arr
- An array to iterate over.iterator(item, callback)
- A function to apply to each item inarr
.The iterator is passed a
callback(err, results)
which must be called once ithas completed with an error (which can be
null
) and an array of results.callback(err, results)
- A callback which is called after all theiterator
functions have finished, or an error occurs. Results is an array containing
the concatenated results of the
iterator
function.
Example
concatSeries(arr, iterator, callback)
Same as concat
, but executes in series instead of parallel.
Control Flow
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. Otherwise, callback
receives an array of results when tasks
have completed.
It is also possible to use an object instead of an array. Each property will be run as a function, and the results will be passed to the final callback
as an object instead of an array. This can be a more readable way of handling results from series
.
Note that while many implementations preserve the order of object properties, the ECMAScript Language Specifcation explicitly states that
The mechanics and order of enumerating the properties is not specified.
So if you rely on the order in which your series of functions are executed, and want this to work on all platforms, consider using an array.
Arguments
tasks
- An array or object containing functions to run, each function is passeda
callback(err, result)
it must call on completion with an errorerr
(which canbe
null
) and an optionalresult
value.callback(err, results)
- An optional callback to run once all the functionshave completed. This function gets a results array (or object) containing all
the result arguments passed to the
task
callbacks.
Example
parallel(tasks, [callback])
Run the tasks
array of functions in parallel, without waiting until the previous function has completed. If any of the functions pass an error to its callback, the main callback
is immediately called with the value of the error. Once the tasks
have completed, the results are passed to the final callback
as an array.
It is also possible to use an object instead of an array. Each property will be run as a function and the results will be passed to the final callback
as an object instead of an array. This can be a more readable way of handling results from parallel
.
Arguments
tasks
- An array or object containing functions to run. Each function is passeda
callback(err, result)
which it must call on completion with an errorerr
(which can be
null
) and an optionalresult
value.callback(err, results)
- An optional callback to run once all the functionshave completed. This function gets a results array (or object) containing all
the result arguments passed to the task callbacks.
Example
parallelLimit(tasks, limit, [callback])
The same as parallel
, only tasks
are executed in parallel with a maximum of limit
tasks executing at any time.
Note that the tasks
are not executed in batches, so there is no guarantee that the first limit
tasks will complete before any others are started.
Arguments
tasks
- An array or object containing functions to run, each function is passeda
callback(err, result)
it must call on completion with an errorerr
(which canbe
null
) and an optionalresult
value.limit
- The maximum number oftasks
to run at any time.callback(err, results)
- An optional callback to run once all the functionshave completed. This function gets a results array (or object) containing all
the result arguments passed to the
task
callbacks.
whilst(test, fn, callback)
Repeatedly call fn
, while test
returns true
. Calls callback
when stopped, or an error occurs.
Arguments
test()
- synchronous truth test to perform before each execution offn
.fn(callback)
- A function which is called each timetest
passes. The function ispassed a
callback(err)
, which must be called once it has completed with anoptional
err
argument.callback(err)
- A callback which is called after the test fails and repeatedexecution of
fn
has stopped.
Example
doWhilst(fn, test, callback)
The post-check version of whilst
. To reflect the difference in the order of operations, the arguments test
and fn
are switched.
doWhilst
is to whilst
as do while
is to while
in plain JavaScript.
until(test, fn, callback)
Repeatedly call fn
until test
returns true
. Calls callback
when stopped, or an error occurs.
The inverse of whilst
.
doUntil(fn, test, callback)
Like doWhilst
, except the test
is inverted. Note the argument ordering differs from until
.
forever(fn, errback)
Calls the asynchronous function fn
with a callback parameter that allows it to call itself again, in series, indefinitely.
If an error is passed to the callback then errback
is called with the error, and execution stops, otherwise it will never be called.
waterfall(tasks, [callback])
Runs the tasks
array of functions in series, each passing their results to the next in the array. However, 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.
Arguments
tasks
- An array of functions to run, each function is passed acallback(err, result1, result2, ...)
it must call on completion. The firstargument is an error (which can be
null
) and any further arguments will bepassed as arguments in order to the next task.
callback(err, [results])
- An optional callback to run once all the functionshave completed. This will be passed the results of the last task's callback.
Example
compose(fn1, fn2...)
Creates a function which is a composition of the passed asynchronous functions. Each function consumes the return value of the function that follows. Composing functions f()
, g()
, and h()
would produce the result of f(g(h()))
, only this version uses callbacks to obtain the return values.
Each function is executed with the this
binding of the composed function.
Arguments
functions...
- the asynchronous functions to compose
Example
seq(fn1, fn2...)
Version of the compose function that is more natural to read. Each following function consumes the return value of the latter function.
Each function is executed with the this
binding of the composed function.
Arguments
functions... - the asynchronous functions to compose
Example
applyEach(fns, args..., callback)
Applies the provided arguments to each function in the array, calling callback
after all functions have completed. If you only provide the first argument, then it will return a function which lets you pass in the arguments as if it were a single function call.
Arguments
fns
- the asynchronous functions to all call with the same argumentsargs...
- any number of separate arguments to pass to the functioncallback
- the final argument should be the callback, called when allfunctions have completed processing
Example
applyEachSeries(arr, iterator, callback)
The same as applyEach
only the functions are applied in series.
queue(worker, concurrency)
Creates a queue
object with the specified concurrency
. Tasks added to the queue
are processed in parallel (up to the concurrency
limit). If all worker
s are in progress, the task is queued until one becomes available. Once a worker
completes a task
, that task
's callback is called.
Arguments
worker(task, callback)
- An asynchronous function for processing a queuedtask, which must call its
callback(err)
argument when finished, with anoptional
error
as an argument.concurrency
- Aninteger
for determining how manyworker
functions should berun in parallel.
Queue objects
The queue
object returned by this function has the following properties and methods:
length()
- a function returning the number of items waiting to be processed.running()
- a function returning the number of items currently being processed.idle()
- a function returning false if there are items waiting or being processed, or true if not.concurrency
- an integer for determining how manyworker
functions should berun in parallel. This property can be changed after a
queue
is created toalter the concurrency on-the-fly.
push(task, [callback])
- add a new task to thequeue
. Callscallback
oncethe
worker
has finished processing the task. Instead of a single task, atasks
arraycan be submitted. The respective callback is used for every task in the list.
unshift(task, [callback])
- add a new task to the front of thequeue
.saturated
- a callback that is called when thequeue
length hits theconcurrency
limit,and further tasks will be queued.
empty
- a callback that is called when the last item from thequeue
is given to aworker
.drain
- a callback that is called when the last item from thequeue
has returned from theworker
.paused
- a boolean for determining whether the queue is in a paused statepause()
- a function that pauses the processing of tasks untilresume()
is called.resume()
- a function that resumes the processing of queued tasks when the queue is paused.
Example
cargo(worker, [payload])
Creates a cargo
object with the specified payload. Tasks added to the cargo will be processed altogether (up to the payload
limit). If the worker
is in progress, the task is queued until it becomes available. Once the worker
has completed some tasks, each callback of those tasks is called. Check out this animation for how cargo
and queue
work.
While queue passes only one task to one of a group of workers at a time, cargo passes an array of tasks to a single worker, repeating when the worker is finished.
Arguments
worker(tasks, callback)
- An asynchronous function for processing an array ofqueued tasks, which must call its
callback(err)
argument when finished, withan optional
err
argument.payload
- An optionalinteger
for determining how many tasks should beprocessed per round; if omitted, the default is unlimited.
Cargo objects
The cargo
object returned by this function has the following properties and methods:
length()
- A function returning the number of items waiting to be processed.payload
- Aninteger
for determining how many tasks should beprocess per round. This property can be changed after a
cargo
is created toalter the payload on-the-fly.
push(task, [callback])
- Addstask
to thequeue
. The callback is calledonce the
worker
has finished processing the task. Instead of a single task, an array oftasks
can be submitted. The respective callback is used for every task in the list.
saturated
- A callback that is called when thequeue.length()
hits the concurrency and further tasks will be queued.empty
- A callback that is called when the last item from thequeue
is given to aworker
.drain
- A callback that is called when the last item from thequeue
has returned from theworker
.
Example
auto(tasks, [callback])
Determines the best order for running the functions in tasks
, based on their requirements. Each function can optionally depend on other functions being completed first, and each function is run as soon as its requirements are satisfied.
If any of the functions pass an error to their callback, it will not complete (so any other functions depending on it will not run), and the main callback
is immediately called with the error. Functions also receive an object containing the results of functions which have completed so far.
Note, all functions are called with a results
object as a second argument, so it is unsafe to pass functions in the tasks
object which cannot handle the extra argument.
For example, this snippet of code:
will have the effect of calling readFile
with the results object as the last argument, which will fail:
Instead, wrap the call to readFile
in a function which does not forward the results
object:
Arguments
tasks
- An object. Each of its properties is either a function or an array ofrequirements, with the function itself the last item in the array. The object's key
of a property serves as the name of the task defined by that property,
i.e. can be used when specifying requirements for other tasks.
The function receives two arguments: (1) a
callback(err, result)
which must becalled when finished, passing an
error
(which can benull
) and the result ofthe function's execution, and (2) a
results
object, containing the results ofthe previously executed functions.
callback(err, results)
- An optional callback which is called when all thetasks have been completed. It receives the
err
argument if anytasks
pass an error to their callback. Results are always returned; however, if
an error occurs, no further
tasks
will be performed, and the resultsobject will only contain partial results.
Example
This is a fairly trivial example, but to do this using the basic parallel and series functions would look like this:
For a complicated series of async
tasks, using the auto
function makes adding new tasks much easier (and the code more readable).
retry([times = 5], task, [callback])
Attempts to get a successful response from task
no more than times
times before returning an error. If the task is successful, the callback
will be passed the result of the successfull task. If all attemps fail, the callback will be passed the error and result (if any) of the final attempt.
Arguments
task(callback, results)
- A function which receives two arguments: (1) acallback(err, result)
which must be called when finished, passing
err
(which can benull
) and theresult
ofthe function's execution, and (2) a
results
object, containing the results ofthe previously executed functions (if nested inside another control flow).
callback(err, results)
- An optional callback which is called when thetask has succeeded, or after the final failed attempt. It receives the
err
andresult
arguments of the last attempt at completing thetask
.
The retry
function can be used as a stand-alone control flow by passing a callback, as shown below:
It can also be embeded within other control flow functions to retry individual methods that are not as reliable, like this:
iterator(tasks)
Creates an iterator function which calls the next function in the tasks
array, returning a continuation to call the next one after that. It's also possible to “peek” at the next iterator with iterator.next()
.
This function is used internally by the async
module, but can be useful when you want to manually control the flow of functions in series.
Arguments
tasks
- An array of functions to run.
Example
apply(function, arguments..)
Creates a continuation function with some arguments already applied.
Useful as a shorthand when combined with other control flow functions. Any arguments passed to the returned function are added to the arguments originally passed to apply.
Arguments
function
- The function you want to eventually apply all arguments to.arguments...
- Any number of arguments to automatically apply when thecontinuation is called.
Example
It's possible to pass any number of additional arguments when calling the continuation:
nextTick(callback)
Calls callback
on a later loop around the event loop. In Node.js this just calls process.nextTick
; in the browser it falls back to setImmediate(callback)
if available, otherwise setTimeout(callback, 0)
, which means other higher priority events may precede the execution of callback
.
This is used internally for browser-compatibility purposes.
Arguments
callback
- The function to call on a later loop around the event loop.
Example
times(n, callback)
Calls the callback
function n
times, and accumulates results in the same manner you would use with map
.
Arguments
n
- The number of times to run the function.callback
- The function to calln
times.
Example
timesSeries(n, callback)
The same as times
, only the iterator is applied to each item in arr
in series. The next iterator
is only called once the current one has completed. The results array will be in the same order as the original.
Utils
memoize(fn, [hasher])
Caches the results of an async
function. When creating a hash to store function results against, the callback is omitted from the hash and an optional hash function can be used.
The cache of results is exposed as the memo
property of the function returned by memoize
.
Arguments
fn
- The function to proxy and cache results from.hasher
- Tn optional function for generating a custom hash for storingresults. It has all the arguments applied to it apart from the callback, and
must be synchronous.
Example
unmemoize(fn)
Undoes a memoize
d function, reverting it to the original, unmemoized form. Handy for testing.
Arguments
fn
- the memoized function
log(function, arguments)
Logs the result of an async
function to the console
. Only works in Node.js or in browsers that support console.log
and console.error
(such as FF and Chrome). If multiple arguments are returned from the async function, console.log
is called on each argument in order.
Arguments
function
- The function you want to eventually apply all arguments to.arguments...
- Any number of arguments to apply to the function.
Example
dir(function, arguments)
Logs the result of an async
function to the console
using console.dir
to display the properties of the resulting object. Only works in Node.js or in browsers that support console.dir
and console.error
(such as FF and Chrome). If multiple arguments are returned from the async function, console.dir
is called on each argument in order.
Arguments
function
- The function you want to eventually apply all arguments to.arguments...
- Any number of arguments to apply to the function.
Example
noConflict()
Changes the value of async
back to its original value, returning a reference to the async
object.
Last updated