FilesExpand file tree

 master

/

reduce.js

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

78 lines (67 loc) · 2.61 KB

 master

/

reduce.js

Copy path

Top

File metadata and controls

• Code
• Blame

78 lines (67 loc) · 2.61 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

'use strict';

Object.defineProperty(exports, "__esModule", {

value: true

});

exports.default = reduce;

var _eachOfSeries = require('./eachOfSeries');

var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);

var _noop = require('lodash/noop');

var _noop2 = _interopRequireDefault(_noop);

var _once = require('./internal/once');

var _once2 = _interopRequireDefault(_once);

var _wrapAsync = require('./internal/wrapAsync');

var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**

* Reduces `coll` into a single value using an async `iteratee` 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.

*

* @name reduce

* @static

* @memberOf module:Collections

* @method

* @alias inject

* @alias foldl

* @category Collection

* @param {Array|Iterable|Object} coll - A collection to iterate over.

* @param {*} memo - The initial state of the reduction.

* @param {AsyncFunction} iteratee - A function applied to each item in the

* array to produce the next step in the reduction.

* The `iteratee` should complete with the next state of the reduction.

* If the iteratee complete with an error, the reduction is stopped and the

* main `callback` is immediately called with the error.

* Invoked with (memo, item, callback).

* @param {Function} [callback] - A callback which is called after all the

* `iteratee` functions have finished. Result is the reduced value. Invoked with

* (err, result).

* @example

*

* async.reduce([1,2,3], 0, function(memo, item, callback) {

* // pointless async:

* process.nextTick(function() {

* callback(null, memo + item)

* });

* }, function(err, result) {

* // result is now equal to the last value of memo, which is 6

* });

*/

function reduce(coll, memo, iteratee, callback) {

callback = (0, _once2.default)(callback || _noop2.default);

var _iteratee = (0, _wrapAsync2.default)(iteratee);

(0, _eachOfSeries2.default)(coll, function (x, i, callback) {

_iteratee(memo, x, function (err, v) {

memo = v;

callback(err);

});

}, function (err) {

callback(err, memo);

});

}

module.exports = exports['default'];