Async.js

eachOf.js

  1. import isArrayLike from 'lodash/isArrayLike';
  3. import breakLoop from './internal/breakLoop';
  4. import eachOfLimit from './eachOfLimit';
  5. import doLimit from './internal/doLimit';
  6. import noop from 'lodash/noop';
  7. import once from './internal/once';
  8. import onlyOnce from './internal/onlyOnce';
  9. import wrapAsync from './internal/wrapAsync';
  11. // eachOf implementation optimized for array-likes
  12. function eachOfArrayLike(coll, iteratee, callback) {
  13.     callback = once(callback || noop);
  14.     var index = 0,
  15.         completed = 0,
  16.         length = coll.length;
  17.     if (length === 0) {
  18.         callback(null);
  19.     }
  21.     function iteratorCallback(err, value) {
  22.         if (err) {
  23.             callback(err);
  24.         } else if ((++completed === length) || value === breakLoop) {
  25.             callback(null);
  26.         }
  27.     }
  29.     for (; index < length; index++) {
  30.         iteratee(coll[index], index, onlyOnce(iteratorCallback));
  31.     }
  32. }
  34. // a generic version of eachOf which can handle array, object, and iterator cases.
  35. var eachOfGeneric = doLimit(eachOfLimit, Infinity);
  37. /**
  38.  * Like [`each`]{@link module:Collections.each}, except that it passes the key (or index) as the second argument
  39.  * to the iteratee.
  40.  *
  41.  * @name eachOf
  42.  * @static
  43.  * @memberOf module:Collections
  44.  * @method
  45.  * @alias forEachOf
  46.  * @category Collection
  47.  * @see [async.each]{@link module:Collections.each}
  48.  * @param {Array|Iterable|Object} coll - A collection to iterate over.
  49.  * @param {AsyncFunction} iteratee - A function to apply to each
  50.  * item in `coll`.
  51.  * The `key` is the item's key, or index in the case of an array.
  52.  * Invoked with (item, key, callback).
  53.  * @param {Function} [callback] - A callback which is called when all
  54.  * `iteratee` functions have finished, or an error occurs. Invoked with (err).
  55.  * @example
  56.  *
  57.  * var obj = {dev: "/dev.json", test: "/test.json", prod: "/prod.json"};
  58.  * var configs = {};
  59.  *
  60.  * async.forEachOf(obj, function (value, key, callback) {
  61.  *     fs.readFile(__dirname + value, "utf8", function (err, data) {
  62.  *         if (err) return callback(err);
  63.  *         try {
  64.  *             configs[key] = JSON.parse(data);
  65.  *         } catch (e) {
  66.  *             return callback(e);
  67.  *         }
  68.  *         callback();
  69.  *     });
  70.  * }, function (err) {
  71.  *     if (err) console.error(err.message);
  72.  *     // configs is now a map of JSON data
  73.  *     doSomethingWith(configs);
  74.  * });
  75.  */
  76. export default function(coll, iteratee, callback) {
  77.     var eachOfImplementation = isArrayLike(coll) ? eachOfArrayLike : eachOfGeneric;
  78.     eachOfImplementation(coll, wrapAsync(iteratee), callback);
  79. }