Array.prototype.reduce()

Prubalo

const array1 = [1, 2, 3, 4];

// 0 + 1 + 2 + 3 + 4
const initialValue = 0;
const sumWithInitial = array1.reduce(
  (accumulator, currentValue) => accumulator + currentValue,
  initialValue,
);

console.log(sumWithInitial);
// Expected output: 10

La funcin reductora recibe cuatro argumentos:

1. Acumulador (acc)
2. Valor Actual (cur)
3. ndice Actual (idx)
4. Array (src)

El valor devuelto de la funcin reductora se asigna al acumulador, cuyo valor se recuerda en cada iteracin de la matriz y, en ltima instancia, se convierte en el valor final, nico y resultante.

Sintaxis

arr.reduce(callback(acumulador, valorActual[, ndice[, array]])[, valorInicial])

Parmetros

callback

Funcin a ejecutar sobre cada elemento del array (excepto para el primero, si no se proporciona valorInicial), que recibe cuatro parmetros:_ acumulador _ : El acumulador acumula el valor devuelto por la funcin callback. Es el valor acumulado devuelto en la ltima invocacin de callback, o el valorInicial, si se provey. (Ver a continuacin).

valorActual

El elemento actual que est siendo procesado en el array.

ndice Opcional

El ndice del elemento actual que est siendo procesado en el array. Empieza desde el ndice 0 si se provee valorInicial. En caso contrario, comienza desde el ndice 1.

array Opcional

El array sobre el cual se llam el mtodo reduce().

valorInicial Opcional

Un valor a usar como primer argumento en la primera llamada de la funcin callback. Si no se proporciona el valorInicial, el primer elemento del array ser utilizado y saltado. Llamando a reduce() sobre un array vaco sin un valorInicial lanzar un TypeError.

Descripcin

El mtodo reduce() ejecuta callback una vez por cada elemento presente en el array, excluyendo los huecos del mismo, recibe cuatro argumentos:

• valorAnterior
• valorActual
• indiceActual
• array

La primera vez que se llama la funcin, valorAnterior y valorActual pueden tener uno de dos valores. Si se provey un valorInicial al llamar a reduce, entonces valorAnterior ser igual al valorInicial y valorActual ser igual al primer elemento del array. Si no se provey un valorInicial, entonces valorAnterior ser igual al primer valor en el array y valorActual ser el segundo.

Si el array est vaco y no se provey un valorInicial lanzar un TypeError. Si el array tiene un slo elemento (sin importar la posicin) y no se provey un valorInicial, o si se provey un valorInicial pero el arreglo est vaco, se retornar ese nico valor sin llamar a la funcin.

Suponga que ocurre el siguiente uso de reduce:

[0, 1, 2, 3, 4].reduce(function (valorAnterior, valorActual, indice, vector) {
  return valorAnterior + valorActual;
});

// Primera llamada
((valorAnterior = 0), (valorActual = 1), (indice = 1));

// Segunda llamada
((valorAnterior = 1), (valorActual = 2), (indice = 2));

// Tercera llamada
((valorAnterior = 3), (valorActual = 3), (indice = 3));

// Cuarta llamada
((valorAnterior = 6), (valorActual = 4), (indice = 4));

// el array sobre el que se llama a reduce siempre es el objeto [0,1,2,3,4]

// Valor Devuelto: 10

Y si proporcionas un valorInicial, el resultado sera como este:

[0, 1, 2, 3, 4].reduce(function (valorAnterior, valorActual, indice, vector) {
  return valorAnterior + valorActual;
}, 10);

// Primera llamada
((valorAnterior = 10), (valorActual = 0), (indice = 0));

// Segunda llamada
((valorAnterior = 10), (valorActual = 1), (indice = 1));

// Tercera llamada
((valorAnterior = 11), (valorActual = 2), (indice = 2));

// Cuarta llamada
((valorAnterior = 13), (valorActual = 3), (indice = 3));

// Quinta llamada
((valorAnterior = 16), (valorActual = 4), (indice = 4));

// el array sobre el que se llama a reduce siempre es el objeto [0,1,2,3,4]

// Valor Devuelto: 20

Polyfill

reduce es una extensin de JavaScript al estndar ECMA-262; como tal puede que no est presente en otras implementaciones del estndar. Puedes trabajar con sto insertando el siguiente cdigo al comienzo de tus scripts, permitiendo el uso de reduce en implementaciones de ECMA-262 que no lo implementan de modo nativo. Este algoritmo es exactamente el mismo usando en Firefox y SpiderMonkey.

if (!Array.prototype.reduce) {
  Array.prototype.reduce = function (fun /*, inicial*/) {
    var longitud = this.length;
    if (typeof fun != "function") throw new TypeError();

    // no se devuelve ningn valor si no hay valor inicial y el array est vaco
    if (longitud == 0 && arguments.length == 1) throw new TypeError();

    var indice = 0;
    if (arguments.length >= 2) {
      var rv = arguments[1];
    } else {
      do {
        if (indice in this) {
          rv = this[indice++];
          break;
        }

        // si el array no contiene valores, no existe valor inicial a devolver
        if (++indice >= longitud) throw new TypeError();
      } while (true);
    }

    for (; indice < longitud; indice++) {
      if (indice in this) rv = fun.call(null, rv, this[indice], indice, this);
    }

    return rv;
  };
}

Ejemplos

Ejemplo: Sumar todos los valores de un array

var total = [0, 1, 2, 3].reduce(function (a, b) {
  return a + b;
});
// total == 6

Ejemplo: Integrar un array a partir de varios arrays

var integrado = [
  [0, 1],
  [2, 3],
  [4, 5],
].reduce(function (a, b) {
  return a.concat(b);
});
// integrado es [0, 1, 2, 3, 4, 5]

Especificaciones

Compatibilidad con navegadores

Ver tambin

• Array.prototype.reduceRight()