Nodejs Array Reduce reduce(combiner, initialValue)

Method Source Code

Array.prototype.reduce = function (combiner, initialValue) {
  var counter,/*from ww  w  . j  a  v  a  2 s  .  c  om*/
    accumulatedValue;

  // If the array is empty, do nothing
  if (this.length === 0) {
    return this;
  }
  else {
    // If the user didn't pass an initial value, use the first item.
    if (arguments.length === 1) {
      counter = 1;
      accumulatedValue = this[0];
    }
    else if (arguments.length >= 2) {
      counter = 0;
      accumulatedValue = initialValue;
    }
    else {
      throw "Invalid arguments.";
    }

    // Loop through the array, feeding the current value and the result of
    // the previous computation back into the combiner function until
    // we've exhausted the entire array and are left with only one value.
    while(counter < this.length) {
      accumulatedValue = combiner(accumulatedValue, this[counter])
      counter++;
    }

    return [accumulatedValue];
  }
};

Related

1. reduce(aggregate, initial)

   Array.prototype.reduce = function(aggregate, initial) {
     const len = this.length;
     let startIndex = 0;
     if(typeof initial === 'undefined') {
       initial = this[0];
       startIndex = 1;
     for(let i = startIndex; i < len; i += 1) {
       initial = aggregate(initial, this[i], i, this);
   ...
   

2. reduce(callback, initial)

   Array.prototype.reduce = function(callback, initial){
     initial = initial || 0;
     for (var i=0; i< this.length; i++) {
       initial = callback(initial, this[i], i, this);
     return  initial;
   wat = [1,2, 3, 4]
   console.log(wat);
   ...
   

3. reduce(callback, initialValue)

   Array.prototype.reduce = function(callback, initialValue) {
     var last, returned;
     this.forEach(function(item, index, array) {
       if (index == 0 && initialValue) {
         returned = initialValue;
       } else if (index == 1 && !initialValue) {
         returned = item;
       } else {
         last = returned, returned = null;
   ...
   

4. reduce(callback, memo)

   Array.prototype.reduce = function (callback, memo) {
       var obj = this;
       var value, accumulated_value = 0;
       for (var i = 0; i < obj.length; i++) {
           value = obj[i];
           accumulated_value = callback.call(null, accumulated_value, value);
       return accumulated_value;
   };
   ...
   

5. reduce(cb, res)

   Array.prototype.reduce = function(cb, res){
       var arr = Object(this);
       for(var i=0;i<arr.length;i++){
           res = cb.call(res, arr[i], i);
       return res;
   

6. reduce(combiner, initialValue)

   Array.prototype.reduce = function(combiner, initialValue) {
     var counter,
       accValue;
     if (this.length === 0) {
       return this;
     else {
       if (arguments.length === 1) {
         counter = 1;
   ...
   

7. reduce(combiner, initialValue)

   Array.prototype.reduce = function(combiner, initialValue) {
     var counter,
       accumulatedValue;
     if (this.length === 0) {
       return this;
     else {
       if (arguments.length === 1) {
         counter = 1;
   ...
   

8. reduce(combiner, initialValue)

   Array.prototype.reduce = function (combiner, initialValue) {
     var counter,
       accumulatedValue;
     if (this.length === 0) {
       return this;
     if (arguments.length === 1) {
       counter = 1;
       accumulatedValue = this[0];
   ...
   

9. reduce(combiner, initialValue)

   Array.prototype.reduce = function(combiner, initialValue) {
     var counter,
       accumulatedValue;
     if (this.length === 1) {
       return this;
     } else {
         if (arguments.length === 1) {
           counter = 1;
           accumulatedValue = this[0];
   ...