array reduce

var array = [36, 25, 6, 15];

array.reduce(function(accumulator, currentValue) {
  return accumulator + currentValue;
}, 0); // 36 + 25 + 6 + 15 = 82

var objs = [
  {name: "Peter", age: 35},
  {name: "John", age: 27},
  {name: "Jake", age: 28}
];

objs.reduce(function(accumulator, currentValue) {
  return accumulator + currentValue.age;
}, 0); // 35 + 27 + 28 = 90

Executes a reducer function on each element of the array, resulting in single output value.

const numbers = [1, -1, 2, 3];

const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue);

// accumulator = 1, currentValue = -1 => accumulator = 0
// accumulator = 0, currentValue = 2 => accumulator = 2
// accumulator = 2, currentValue = 3 => accumulator = 5

// expected output 5

var age = [ { Id: 16 }, { Id: 24 }, { Id: 32 } ];

var ageById = age.reduce((byId, age) => (byId[age.Id] = age, byId), {});
console.log(ageById);
would print out:
`{16:{Id: 16},24:{Id: 24},32:{Id: 32}}`

const sum = array.reduce((accumulator, element) => {
  return accumulator + element;
}, 0);
// An example that will loop through an array adding
// each element to an accumulator and returning it
// The 0 at the end initializes accumulator to start at 0
// If array is [2, 4, 6], the returned value in sum
// will be 12 (0 + 2 + 4 + 6)

const product = array.reduce((accumulator, element) => {
  return accumulator * element;
}, 1);
// Multiply all elements in array and return the total
// Initialize accumulator to start at 1
// If array is [2, 4, 6], the returned value in product
// will be 48 (1 * 2 * 4 * 6)

array.reduce(function(acumulador, elementoAtual, indexAtual, arrayOriginal), valorInicial)

[1,2,3,4,5].reduce((acc, current)=>acc+current, 0)

arr.reduce(callback( accumulator, currentValue[, index[, array]] )[, initialValue])

/* this is our initial value i.e. the starting point*/
const initialValue = 0;

/* numbers array */
const numbers = [5, 10, 15];

/* reducer method that takes in the accumulator and next item */
const reducer = (accumulator, item) => {
  return accumulator + item;
};

/* we give the reduce method our reducer function
  and our initial value */
const total = numbers.reduce(reducer, initialValue)

arr.reduce(callback( accumulator, currentValue[, index[, array]] ) {
  // return result from executing something for accumulator or currentValue
}[, initialValue]);

const array1 = [1, 2, 3, 4];
const reducer = (accumulator, currentValue) => accumulator + currentValue;

// 1 + 2 + 3 + 4
console.log(array1.reduce(reducer));
// expected output: 10

// 5 + 1 + 2 + 3 + 4
console.log(array1.reduce(reducer, 5));
// expected output: 15