Async.js

reduce.js

  1. import eachOfSeries from './eachOfSeries';
  2. import noop from 'lodash/noop';
  3. import once from './internal/once';
  4. import wrapAsync from './internal/wrapAsync';
  6. /**
  7.  * Reduces `coll` into a single value using an async `iteratee` to return each
  8.  * successive step. `memo` is the initial state of the reduction. This function
  9.  * only operates in series.
  10.  *
  11.  * For performance reasons, it may make sense to split a call to this function
  12.  * into a parallel map, and then use the normal `Array.prototype.reduce` on the
  13.  * results. This function is for situations where each step in the reduction
  14.  * needs to be async; if you can get the data before reducing it, then it's
  15.  * probably a good idea to do so.
  16.  *
  17.  * @name reduce
  18.  * @static
  19.  * @memberOf module:Collections
  20.  * @method
  21.  * @alias inject
  22.  * @alias foldl
  23.  * @category Collection
  24.  * @param {Array|Iterable|Object} coll - A collection to iterate over.
  25.  * @param {*} memo - The initial state of the reduction.
  26.  * @param {AsyncFunction} iteratee - A function applied to each item in the
  27.  * array to produce the next step in the reduction.
  28.  * The `iteratee` should complete with the next state of the reduction.
  29.  * If the iteratee complete with an error, the reduction is stopped and the
  30.  * main `callback` is immediately called with the error.
  31.  * Invoked with (memo, item, callback).
  32.  * @param {Function} [callback] - A callback which is called after all the
  33.  * `iteratee` functions have finished. Result is the reduced value. Invoked with
  34.  * (err, result).
  35.  * @example
  36.  *
  37.  * async.reduce([1,2,3], 0, function(memo, item, callback) {
  38.  *     // pointless async:
  39.  *     process.nextTick(function() {
  40.  *         callback(null, memo + item)
  41.  *     });
  42.  * }, function(err, result) {
  43.  *     // result is now equal to the last value of memo, which is 6
  44.  * });
  45.  */
  46. export default function reduce(coll, memo, iteratee, callback) {
  47.     callback = once(callback || noop);
  48.     var _iteratee = wrapAsync(iteratee);
  49.     eachOfSeries(coll, function(x, i, callback) {
  50.         _iteratee(memo, x, function(err, v) {
  51.             memo = v;
  52.             callback(err);
  53.         });
  54.     }, function(err) {
  55.         callback(err, memo);
  56.     });
  57. }