Async.js

parallel.js

  1. import eachOf from './eachOf';
  2. import parallel from './internal/parallel';
  4. /**
  5.  * Run the `tasks` collection of functions in parallel, without waiting until
  6.  * the previous function has completed. If any of the functions pass an error to
  7.  * its callback, the main `callback` is immediately called with the value of the
  8.  * error. Once the `tasks` have completed, the results are passed to the final
  9.  * `callback` as an array.
  10.  *
  11.  * **Note:** `parallel` is about kicking-off I/O tasks in parallel, not about
  12.  * parallel execution of code.  If your tasks do not use any timers or perform
  13.  * any I/O, they will actually be executed in series.  Any synchronous setup
  14.  * sections for each task will happen one after the other.  JavaScript remains
  15.  * single-threaded.
  16.  *
  17.  * **Hint:** Use [`reflect`]{@link module:Utils.reflect} to continue the
  18.  * execution of other tasks when a task fails.
  19.  *
  20.  * It is also possible to use an object instead of an array. Each property will
  21.  * be run as a function and the results will be passed to the final `callback`
  22.  * as an object instead of an array. This can be a more readable way of handling
  23.  * results from {@link async.parallel}.
  24.  *
  25.  * @name parallel
  26.  * @static
  27.  * @memberOf module:ControlFlow
  28.  * @method
  29.  * @category Control Flow
  30.  * @param {Array|Iterable|Object} tasks - A collection of
  31.  * [async functions]{@link AsyncFunction} to run.
  32.  * Each async function can complete with any number of optional `result` values.
  33.  * @param {Function} [callback] - An optional callback to run once all the
  34.  * functions have completed successfully. This function gets a results array
  35.  * (or object) containing all the result arguments passed to the task callbacks.
  36.  * Invoked with (err, results).
  37.  *
  38.  * @example
  39.  * async.parallel([
  40.  *     function(callback) {
  41.  *         setTimeout(function() {
  42.  *             callback(null, 'one');
  43.  *         }, 200);
  44.  *     },
  45.  *     function(callback) {
  46.  *         setTimeout(function() {
  47.  *             callback(null, 'two');
  48.  *         }, 100);
  49.  *     }
  50.  * ],
  51.  * // optional callback
  52.  * function(err, results) {
  53.  *     // the results array will equal ['one','two'] even though
  54.  *     // the second function had a shorter timeout.
  55.  * });
  56.  *
  57.  * // an example using an object instead of an array
  58.  * async.parallel({
  59.  *     one: function(callback) {
  60.  *         setTimeout(function() {
  61.  *             callback(null, 1);
  62.  *         }, 200);
  63.  *     },
  64.  *     two: function(callback) {
  65.  *         setTimeout(function() {
  66.  *             callback(null, 2);
  67.  *         }, 100);
  68.  *     }
  69.  * }, function(err, results) {
  70.  *     // results is now equals to: {one: 1, two: 2}
  71.  * });
  72.  */
  73. export default function parallelLimit(tasks, callback) {
  74.     parallel(eachOf, tasks, callback);
  75. }