--- title: Array.prototype.reduce() slug: Web/JavaScript/Referencje/Obiekty/Array/Reduce translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce ---

Podsumowanie

Metoda reduce() wywołuje funkcję względem wartości przyrostowej z każdego wywołania i kolejnego elementu tablicy (od lewej do prawej) w celu sprowadzenia tej tablicy do pojedynczej wartości.

Składnia

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

Parametry

callback

Funkcja wykonywana na każdej wartości w tablicy, przyjmuje cztery argumenty:

previousValue
: Wartość zwróconą w ostatnim wywołaniu funkcji callback, lub initialValue, jeśli ta została dostarczona. (Patrz niżej.)
currentValue: Obecnie przetwarzany element w tablicy.
index: Indeks w tablicy obecnie przetwarzanego elementu.
array: Tablica, na której została wykonana funkcja reduce .

initialValue

Opcjonalne. Obiekt który będzie użyty jako pierwszy argument pierwszego wywołania funkcji callback.

Opis

reduce wykonuje funkcję callback raz dla każdego elementu występującego w tablicy, wyłączając dziury. Funkcja callback przyjmuje cztery argumenty: wartość początkową (lub wartość poprzedniego wywołania callback), wartość obecnego elementu, jego indeks, oraz tablicę na której zachodzi proces iteracji.

Przy pierwszym wywołaniu funkcji callback, previousValue oraz currentValue mogą przyjąć jedną z dwóch wartości. Jeżeli initialValue było dostarczone w wywołaniu, wtedy previousValue przyjmie wartość podaną jako initialValue, natomiast currentValue przyjmie wartość pierwszego elementu tablicy. Jeśli initialValue nie było podane, wtedy previousValue będzie miało wartość pierwszego elementu tablicy, natomiast currentValue będzie równe elementowi drugiemu.

Jeżeli tablica jest pusta oraz initialValue nie zostało dostarczone, będzie rzucony błąd {{jsxref("Global_Objects/TypeError", "TypeError")}}. Jeśli natomiast tablica ma jeden tylko element (bez względu na jego pozycję) i initialValue nie zostało podane, lub dostarczono initialValue, ale tablica jest pusta, wtedy ta jedyna wartość zostanie zwrócona, bez wywoływania funkcji callback.

Przyjmijmy, że wystąpiło następujące wywolanie funkcji reduce:

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

Funkcja callback będzie wywołana cztery razy, z argumentami i wartościami zwrotnymi przy każdym wołaniu jak następuje:

	`previousValue`	`currentValue`	`index`	`array`	wartość zwracana
pierwsze wywołanie	`0`	`1`	`1`	`[0, 1, 2, 3, 4]`	`1`
drugie wywołanie	`1`	`2`	`2`	`[0, 1, 2, 3, 4]`	`3`
trzecie wywołanie	`3`	`3`	`3`	`[0, 1, 2, 3, 4]`	`6`
czwarte wywołanie	`6`	`4`	`4`	`[0, 1, 2, 3, 4]`	`10`

Wartość zwrócona ostatecznie przez reduce będzie tą z ostatniego wywołania funcji callback (10).

Natomiast, jeśli dostarczylibyśmy wartość początkową jako drugi argument funkcji przekazanej do reduce, wynik wyglądałby jak poniżej:

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

	`previousValue`	`currentValue`	`index`	`array`	wartość zwracana
pierwsze wywołanie	`10`	`0`	`0`	`[0, 1, 2, 3, 4]`	`10`
drugie wywołanie	`10`	`1`	`1`	`[0, 1, 2, 3, 4]`	`11`
trzecie wywołanie	`11`	`2`	`2`	`[0, 1, 2, 3, 4]`	`13`
czwarte wywołanie	`13`	`3`	`3`	`[0, 1, 2, 3, 4]`	`16`
piąte wywołanie	`16`	`4`	`4`	`[0, 1, 2, 3, 4]`	`20`

Tym razem wartość zwrócona przez reduce będzie wynosiła 20.

Przykłady

Przykład: Zsumowanie wszystkich wartości w tablicy.

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

Przykład: Spłaszczenie tablicy tablic

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 zostało dodane do standardu ECMA-262 w edycji piątej i jako takie może nie występować we wszystkich implementacji standardu. Można obejśc ten brak poprzez wstawienie poniższego kodu na początku skryptu, co pozwala na użycie reduce z implementacjami, które nie wspierają tej funkcji.

// 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;
  };
}

Specyfikacja

Specyfikacja	Stan	Komentarz
{{SpecName('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce')}}	{{Spec2('ES5.1')}}	Definicja początkowa. Wprowadzon w JavaScript 1.8.
{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce')}}	{{Spec2('ES6')}}

Wspierane przeglądarki

Feature	Chrome	Firefox (Gecko)	Internet Explorer	Opera	Safari
Basic support	{{CompatVersionUnknown}}	{{CompatGeckoDesktop("1.9")}}	{{CompatIE("9")}}	{{CompatOpera("10.5")}}	{{CompatSafari("4.0")}}

Feature	Android	Chrome for Android	Firefox Mobile (Gecko)	IE Mobile	Opera Mobile	Safari Mobile
Basic support	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}

Zobacz też

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