--- title: Array.prototype.reduce() slug: Web/JavaScript/Reference/Global_Objects/Array/Reduce translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce original_slug: Web/JavaScript/Referencia/Objectes_globals/Array/Reduce ---

El mètode reduce() aplica una funció sobre un acumulador i cada valor de l'array (de esquerra a dreta) perr a reduir-lo a un sol valor.

sintaxi

arr.reduce(callback[, valorInicial])

Parameters

callback

Funció a executar per a cada valor de l'array. Rep quatre arguments:

valorPrevi: El valor retornat prèviament en l'última invocació de la funció callback, o bé valorInicial, si s'ha proporcionat (vegeu més abaix).
valorActual: L'element essent processat actualment a l'array.
index: La posició de l'element essent processat actualment a l'array.
array: L'array al qual s'ha cridat el mètode reduce.

valorInicial

Opcional. Valor a utilitzar com a primer argument a la primera crida de la funció callback.

Descripció

reduce executa la funció callback un cop per cada element present a l'array, excloent forats a l'array, i rep quatre arguments:

valorPrevi
valorActual
index
array

El primer cop que es crida callback, valorAnterior i valorActual reben el valor de la forma descrita a continuació. Si es proporciona valorInicial a la crida de reduce, valorAnterior rebrà el valor de valorInicial i valorActual serà igual al primer valor de l'array. Si no es proporciona valorInicial, valorAnterior serà igual al primer valor de l'array i valorActual serà igual al segon.

Si l'array és buit i no s'ha proporcionat valorInicial, es llençarà {{jsxref("Global_Objects/TypeError", "TypeError")}}. Si l'array només té un element (sense importar la seva posició) i no s'ha proporcionat valorInicial, o si valorInicial s'ha proporcionat però l'array és buit, es retornarà aquest únic valor sense realitzar cap crida a callback.

Suposem que s'ha utilitzar reduce de la forma següent:

[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) {
  return previousValue + currentValue;
});

La funció callback es cridarà quatre cops, on els arguments i els valors a retornar es mostren a continuació:

	`valorAnterior`	`valorActual`	`index`	`array`	valor retornat
primera crida	`0`	`1`	`1`	`[0, 1, 2, 3, 4]`	`1`
segons crida	`1`	`2`	`2`	`[0, 1, 2, 3, 4]`	`3`
tercera crida	`3`	`3`	`3`	`[0, 1, 2, 3, 4]`	`6`
quarta crida	`6`	`4`	`4`	`[0, 1, 2, 3, 4]`	`10`

El valor retornat per reduce serà el de l'última invocació a callback (10).

Si es proporcionés el valor inicial com a segon argument de reduce, el resultat seria el següent:

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

	`valorAnterior`	`valorActual`	`index`	`array`	valor retornat
primera crida	`10`	`0`	`0`	`[0, 1, 2, 3, 4]`	`10`
segona crida	`10`	`1`	`1`	`[0, 1, 2, 3, 4]`	`11`
tercera crida	`11`	`2`	`2`	`[0, 1, 2, 3, 4]`	`13`
quarta crida	`13`	`3`	`3`	`[0, 1, 2, 3, 4]`	`16`
cinquena crida	`16`	`4`	`4`	`[0, 1, 2, 3, 4]`	`20`

El valor de la crida final (20) és el retornat per la funció reduce.

Exemples

Sumar tots els valors d'un array

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

Aplanar un array d'arrays

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

Polyfill

Array.prototype.reduce va ser afegida a l'standard ECMA-262 a la cinquena edició; degut a això aquesta no estar present a totes les implementacions de l'standard. És possible simular-la en aquests casos mitjançant l'inserció del codi que trobareu a continuació a l'inici dels vostres scripts, tot permetent-vos utilitzar reduce en implementacions que no la suportin de forma nativa.

// Production steps of ECMA-262, Edition 5, 15.4.4.21
// Reference: http://es5.github.io/#x15.4.4.21
if (!Array.prototype.reduce) {
  Array.prototype.reduce = function(callback /*, initialValue*/) {
    'use strict';
    if (this == null) {
      throw new TypeError('Array.prototype.reduce called on null or undefined');
    }
    if (typeof callback !== 'function') {
      throw new TypeError(callback + ' is not a function');
    }
    var t = Object(this), len = t.length >>> 0, k = 0, value;
    if (arguments.length == 2) {
      value = arguments[1];
    } else {
      while (k < len && !(k in t)) {
        k++;
      }
      if (k >= len) {
        throw new TypeError('Reduce of empty array with no initial value');
      }
      value = t[k++];
    }
    for (; k < len; k++) {
      if (k in t) {
        value = callback(value, t[k], k, t);
      }
    }
    return value;
  };
}

Especificacions

Especificació	Estat	Comentaris
{{SpecName('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce')}}	{{Spec2('ES5.1')}}	Definició inicial. Implementat a JavaScript 1.8.
{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce')}}	{{Spec2('ES6')}}

Compatibilitat amb navegadors

Característica	Chrome	Firefox (Gecko)	Internet Explorer	Opera	Safari
Suport bàsic	{{CompatVersionUnknown}}	{{CompatGeckoDesktop("1.9")}}	{{CompatIE("9")}}	{{CompatOpera("10.5")}}	{{CompatSafari("4.0")}}

Característica	Android	Chrome for Android	Firefox Mobile (Gecko)	IE Mobile	Opera Mobile	Safari Mobile
Suport bàsic	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}

Vegeu també

{{jsxref("Array.prototype.reduceRight()")}}