Array.prototype

W tym rozdziale dowiesz się...

constructor

Array.prototype.constructor
Wartość:
Function - konstruktor obiektu

Zawiera wbudowany konstruktor obiektu Array.

Przykład:

Array.prototype.constructor === Array;  // true
new Array().constructor === Array;      // true
Array.prototype.constructor === Object; // false

toString

Array.prototype.toString()
Wartość:
String - reprezentacja tekstowa tablicy

Zwraca tekst będący listą wszystkich kolejnych elementów tablicy, rozdzielonych przecinkami.

Funkcja toString jest wywoływana automatycznie zawsze wtedy, gdy oczekiwana jest wartość tekstowa, a przekazano obiekt tablicy.

Przykład:

new Array([true, 1, "test"]).toString();             // "true,1,test"
[false, 0, "", null, undefined, NaN, Infinity] + ""; // "false,0,,,,NaN,Infinity"

toLocaleString

Array.prototype.toLocaleString()
Wartość:
String - tekstowa reprezentacja elementów tablicy zgodnie z rodzimym językiem użytkownika
Wyjątki:
TypeError - element tablicy nie posiada metody toLocaleString

Działa analogicznie jak Array.prototype.toString, ale przekształca każdy element tablicy na tekst, zgodnie z ustawieniami rodzimego języka użytkownika systemu. Na przykład w języku polskim liczby rzeczywiste zapisujemy z użyciem znaku przecinka, podczas gdy angielskim - z użyciem kropki. Dodatkowo w języku polskim dla poprawy czytelności kolejne tysiące liczby możemy oddzielać od siebie znakiem spacji. Zwykle również inaczej zapisujemy daty z kalendarza.

Przykład:

new Array([1000.2]).toLocaleString(); // np.: "1 000,2"
new Array([1000.2]).toString();       // "1000.2"
var date = new Date(2000, 0, 31, 20, 30);
new Array([date]).toLocaleString();   // np.: "31 styczeń 2000 20:30:00"
new Array([date]).toString();         // np.: "Mon Jan 31 2000 20:30:00 GMT+0100"
 
var obj = {};
obj.toLocaleString = undefined;
new Array([obj]).toLocaleString();    // TypeError

concat

Array.prototype.concat()
Array.prototype.concat(item1)
Array.prototype.concat(item1, item2...)
Parametry:
item1, item2... - lista elementów
Wartość:
Array - nowa tablica

Tworzy nową tablicę, będącą połączeniem aktualnych i nowych elementów. Jeżeli argument funkcji sam jest tablicą, każdy z jego elementów jest dodawany po kolei do nowej tablicy. Oryginalna tablica nigdy nie jest zmieniana.

Przykład:

var items = [1, 2];
items.concat();          // [1, 2]
items.concat(3);         // [1, 2, 3]
items.concat(3, [4, 5]); // [1, 2, 3, 4, 5]
items;                   // [1, 2]

join

Array.prototype.join()
Array.prototype.join(separator)
Parametry:
String separator - tekst rozdzielający poszczególne elementy tablicy (domyślnie: ",")
Wartość:
String - tekstowe połączenie kolejnych elementów tablicy

Przekształca tablicę na tekst podobnie jak funkcja Array.prototype.toString, ale pozwala dodatkowo określić tekst, za pomocą którego zostaną rozdzielone kolejne elementy (dla funkcji Array.prototype.toString jest to zawsze: ",").

Przykład:

var items = [1, 2];
items.join("; ");             // "1; 2"
"[" + items.join(", ") + "]"; // "[1, 2]"

pop

Array.prototype.pop()
Wartość:
ostatni element tablicy

Usuwa ostatni element z tablicy i zwraca go. Jeżeli tablica nie zawiera żadnych elementów, funkcja zwraca wartość undefined. Jednak wartości niezdefiniowane mogą być normalnie przechowywane w tablicy, dlatego nie musi to od razu oznaczać, że tablica w każdym takim przypadku jest na pewno pusta.

Przykład:

var items = [1, 2];
items.pop(); // 2
items;       // [1]
items.pop(); // 1
items;       // []
items.pop(); // undefined

push

Array.prototype.push()
Array.prototype.push(item1)
Array.prototype.push(item1, item2...)
Parametry:
item1, item2... - lista nowych elementów
Wartość:
Number - nowa długość tablicy

Dodaje nowe elementy na końcu tablicy.

Przykład:

var items = [1, 2];
items.push();              // 2
items;                     // [1, 2]
items.push(3, [4.1, 4.2]); // 4
items;                     // [1, 2, 3, [4.1, 4.2]]

reverse

Array.prototype.reverse()
Wartość:
Array - odwrócona tablica

Odwraca kolejność elementów tablicy. Nie tworzy nowej instancji obiektu, ale zawsze zmienia bieżący obiekt. Nie działa rekurencyjnie, tzn. jeśli elementem tablicy jest inna tablica, nie zmienia kolejności jej elementów.

Przykład:

var items = [1, 2, [3.1, 3.2]];
items.reverse(); // [[3.1, 3.2], 2, 1]
items;           // [[3.1, 3.2], 2, 1]

shift

Array.prototype.shift()
Wartość:
pierwszy element tablicy

Usuwa pierwszy element z tablicy i zwraca go. Jeżeli tablica nie zawiera żadnych elementów, funkcja zwraca wartość undefined. Jednak wartości niezdefiniowane mogą być normalnie przechowywane w tablicy, dlatego nie musi to od razu oznaczać, że tablica w każdym takim przypadku jest na pewno pusta.

Przykład:

var items = [1, 2];
items.shift(); // 1
items;         // [2]
items.shift(); // 2
items;         // []
items.shift(); // undefined

slice

Array.prototype.slice()
Array.prototype.slice(start)
Array.prototype.slice(start, end)
Parametry:
Number start - indeks elementu początkowego (domyślnie: 0)
Number end - indeks elementu po końcowym (domyślnie: długość tablicy)
Wartość:
Array - wycięte elementy

Tworzy nową tablicę, będącą wycinkiem, składający się z kolejnych elementów poczynając od początkowego (na który wskazuje indeks start) aż do końcowego (przed indeksem end).

  • Jeżeli do funkcji nie zostaną przekazane żadne argumenty, będzie zwrócona kopia całej tablicy.
  • Jeżeli argument end nie zostanie podany, wycinek będzie zawierał wszystkie elementy od start do końca tablicy.
  • Jeżeli wartość argumentu będzie mniejsza od zera, odliczanie indeksu rozpocznie się od końca tablicy.

Array.prototype.slice nie zmienia oryginalnej tablicy, tak jak to robi funkcja Array.prototype.splice.

Przykład:

var items = [1, 2, 3, 4];
 
items.slice();       // [1, 2, 3, 4]
items.slice(1);      // [2, 3, 4]
items.slice(-2);     // [3, 4] == items.slice(2);
items.slice(1, 3);   // [2, 3]
items.slice(1, -1);  // [2, 3] == items.slice(1, 3);
items.slice(-3, -1); // [2, 3]
 
items.slice(0, 0);   // []
items.slice(1, 1);   // []
items.slice(3, 1);   // []
items.slice(-1, -2); // []     == items.slice(3, 2);
 
items;               // [1, 2, 3, 4]

sort

Array.prototype.sort()
Array.prototype.sort(comparefn)
Parametry:
Function comparefn - funkcja porównująca dwa elementy tablicy (domyślnie elementy są sortowane w porządku alfabetycznym); zwraca:
  • liczbę mniejszą od zera - gdy pierwszy element jest mniejszy niż drugi
  • zero - gdy oba elementy są równe
  • liczbę większą od zera - gdy pierwszy element jest większy niż drugi
Wartość:
Array - posortowana tablica

Układa elementy tablicy w określonym porządku. Domyślnie odbywa się to alfabetycznie, ale możemy określić swój własny układ, podając funkcję porównującą, która będzie wywoływana zawsze dla dwóch elementów tablicy - za każdym razem innych - tyle razy ile będzie konieczne, aby posortować całą tablicę.

Funkcja Array.prototype.sort nie tworzy nowej instancji tablicy, ale zawsze zmienia oryginalną, która jest również przez nią zwracana.

Przykład:

var items = [3, 2, 1];
items.sort();   // [1, 2, 3]
items;          // [1, 2, 3]
 
var f = function (x, y) {
    return y - x;
};
items.sort(f);  // [3, 2, 1]
items;          // [3, 2, 1]
 
var persons = [{name: "John"}, {name: "Anna"}, {name: "Tom"}];
f = function (x, y) {
    if (x.name < y.name) return -1;
    if (x.name > y.name) return 1;
    return 0;
};
persons.sort(f); // [{name: "Anna"}, {name: "John"}, {name: "Tom"}]

splice

Array.prototype.splice()
Array.prototype.splice(start, deleteCount)
Array.prototype.splice(start, deleteCount, item1)
Array.prototype.splice(start, deleteCount, item1, item2...)
Parametry:
Number start - indeks elementu początkowego
Number deleteCount - ile kolejnych elementów usunąć bądź podmienić
item1, item2... - lista elementów na podmianę
Wartość:
Array - wycięte elementy

Tworzy nową tablicę, będącą wycinkiem, składający się z kolejnych elementów poczynając od tego, na który wskazuje indeks start i zawierającym tyle elementów, na ile wskazuje argument deleteCount. Następnie w miejsce wycinka są wstawiane elementy, określone argumentami: item1, item2..., a jeżeli ich nie podamy, wycinek po prostu jest usuwany z oryginalnej tablicy.

  • Jeżeli do funkcji nie zostaną przekazane żadne argumenty, będzie zwrócona pusty wycinek, a oryginalna tablica nie ulegnie zmianie.
  • Jeżeli wartość argumentu start będzie mniejsza od zera, odliczanie indeksu rozpocznie się od końca tablicy.

Array.prototype.splice - inaczej niż funkcja Array.prototype.slice - zmienia oryginalną tablicę.

Przykład:

var items = [1, 2, 3, 4, 5];
 
items.splice();                  // []
items;                           // [1, 2, 3, 4, 5]
items.slice(0, 0);               // []
items;                           // [1, 2, 3, 4, 5]
items.splice(1, 2);              // [2, 3]
items;                           // [1, 4, 5]
items.splice(1, 0, 2, 3);        // []
items;                           // [1, 2, 3, 4, 5]
items.splice(-2, 2);             // [4, 5] == items.splice(3, 2);
items;                           // [1, 2, 3]
items.splice(1, 1, [2.1, 2.2]);  // [2]
items;                           // [1, [2.1, 2.2], 3]
items.splice(1, 10, 2, 3, 4, 5); // [[2.1, 2.2], 3]
items;                           // [1, 2, 3, 4, 5]

unshift

Array.prototype.unshift()
Array.prototype.unshift(item1)
Array.prototype.unshift(item1, item2...)
Parametry:
item1, item2... - lista nowych elementów
Wartość:
Number - nowa długość tablicy

Dodaje nowe elementy na początku tablicy.

Przykład:

var items = [1, 2];
items.unshift();                // 2
items;                          // [1, 2]
items.unshift([-1.2, -1.1], 0); // 4
items;                          // [[-1.2, -1.1], 0, 1, 2]

indexOf

(interpretuje: Internet Explorer 9, Firefox, Opera, Chrome)

Array.prototype.indexOf(searchElement)
Array.prototype.indexOf(searchElement, fromIndex)
Parametry:
searchElement - poszukiwany element
Number fromIndex - początkowy indeks poszukiwań (domyślnie: 0)
Wartość:
Number - indeks pierwszego znalezionego elementu

Przeszukuje tablicę w kierunku jej końca pod kątem występowania w niej podanego elementu. Jeżeli element nie zostanie znaleziony, funkcja zwraca liczbę -1. Możliwe jest również ograniczenie zakresu poszukiwań do elementów o indeksie nie mniejszym niż podany. Jeżeli argument fromIndex jest mniejszy od zera, odliczane jest tyle elementów od końca tablicy i dalej następuje jej przeszukanie w kierunku końca.

Przypominam, że pierwszy element tablicy ma indeks 0, a więc taka wartość zwrócona przez funkcję oznacza, że poszukiwany element został znaleziony (na samym początku tablicy).

Przykład:

var items = [1, 2, 3, 1];
items.indexOf(1);      // 0
items.indexOf(1, 1);   // 3
items.indexOf(1, -3);  // 3  == items.indexOf(1, 2)
items.indexOf(1, -10); // 0  == items.indexOf(1, 0)
items.indexOf(1, 10);  // -1 == items.indexOf(1, 4)
items.indexOf(0);      // -1

lastIndexOf

(interpretuje: Internet Explorer 9, Firefox, Opera, Chrome)

Array.prototype.lastIndexOf(searchElement)
Array.prototype.lastIndexOf(searchElement, fromIndex)
Parametry:
searchElement - poszukiwany element
Number fromIndex - początkowy indeks poszukiwań (domyślnie: -1)
Wartość:
Number - indeks ostatniego znalezionego elementu

Przeszukuje tablicę w kierunku jej początku pod kątem występowania w niej podanego elementu. Jeżeli element nie zostanie znaleziony, funkcja zwraca liczbę -1. Możliwe jest również ograniczenie zakresu poszukiwań do elementów o indeksie nie większym niż podany. Jeżeli argument fromIndex jest mniejszy od zera, odliczane jest tyle elementów od końca tablicy i dalej następuje jej przeszukanie w kierunku początku.

Przypominam, że pierwszy element tablicy ma indeks 0, a więc taka wartość zwrócona przez funkcję oznacza, że poszukiwany element został znaleziony (na samym początku tablicy).

Przykład:

var items = [1, 2, 3, 1];
items.lastIndexOf(1);      // 3
items.lastIndexOf(1, -2);  // 0 == items.lastIndexOf(1, 2)
items.lastIndexOf(1, 2);   // 0
items.lastIndexOf(1, 10);  // 3
items.lastIndexOf(1, -10); // -1
items.lastIndexOf(0);      // -1

every

(interpretuje: Internet Explorer 9, Firefox, Opera, Chrome)

Array.prototype.every(callbackfn)
Array.prototype.every(callbackfn, thisArg)
Parametry:
Function callbackfn - funkcja testująca przyjmująca argumenty:
  • kValue - element tablicy
  • Number k - indeks elementu tablicy
  • Array O - oryginalna tablica
thisArg - wartość bieżącego obiektu this dostępnego w czasie wywołania wewnątrz ciała funkcji (domyślnie: undefined)
Wartość:
Boolean - czy dla wszystkich elementów tablicy funkcja testująca zwraca wartość true
Wyjątki:
TypeError - callbackfn nie jest funkcją

Pozwala sprawdzić, czy wszystkie elementy tablicy spełniają określony warunek. Elementy, które nie zostały jawnie dodane do tablicy, są pomijane.

Jest odpowiednikiem operatora && (i - ang. and) przy działaniach na wartościach skalarnych.

Przykład:

var items = [3, 2, 1];
 
var f = function (x) {
    return x > 0;
};
items.every(f);                   // true
 
f = function (x) {
    return x < 0;
};
items.every(f);                   // false
 
var GreaterThan = function (value) {
    this.value = value;
    this.tests = 0;
};
GreaterThan.prototype.test = function (value) {
    ++this.tests;
    return value > this.value;
};
 
var tester = new GreaterThan(0);
items.every(tester.test, tester); // true
tester.tests;                     // 3
 
tester = new GreaterThan(2);
items.every(tester.test, tester); // false
tester.tests;                     // 2
 
items = [1, 2];
items[3] = 3;
items.length;                     // 4
tester = new GreaterThan(0);
items.every(tester.test, tester); // true
tester.tests;                     // 3
 
items.every(null);                // TypeError
items.every(undefined);           // TypeError
items.every({});                  // TypeError

some

(interpretuje: Internet Explorer 9, Firefox, Opera, Chrome)

Array.prototype.some(callbackfn)
Array.prototype.some(callbackfn, thisArg)
Parametry:
Function callbackfn - funkcja testująca przyjmująca argumenty:
  • kValue - element tablicy
  • Number k - indeks elementu tablicy
  • Array O - oryginalna tablica
thisArg - wartość bieżącego obiektu this dostępnego w czasie wywołania wewnątrz ciała funkcji (domyślnie: undefined)
Wartość:
Boolean - czy przynajmniej dla jednego elementu tablicy funkcja testująca zwraca wartość true
Wyjątki:
TypeError - callbackfn nie jest funkcją

Pozwala sprawdzić, czy przynajmniej jeden element tablicy spełnia określony warunek. Elementy, które nie zostały jawnie dodane do tablicy, są pomijane.

Jest odpowiednikiem operatora || (lub - ang. or) przy działaniach na wartościach skalarnych.

Przykład:

var items = [3, 2, 1];
 
var f = function (x) {
    return x > 0;
};
items.some(f);                   // true
 
f = function (x) {
    return x < 0;
};
items.some(f);                   // false
 
var GreaterThan = function (value) {
    this.value = value;
    this.tests = 0;
};
GreaterThan.prototype.test = function (value) {
    ++this.tests;
    return value > this.value;
};
 
var tester = new GreaterThan(0);
items.some(tester.test, tester); // true
tester.tests;                    // 1
 
tester = new GreaterThan(4);
items.some(tester.test, tester); // false
tester.tests;                    // 3
 
items = [1, 2];
items[3] = 3;
items.length;                    // 4
tester = new GreaterThan(4);
items.some(tester.test, tester); // false
tester.tests;                    // 3
 
items[2] = undefined;
items.length;                    // 4
tester = new GreaterThan(4);
items.some(tester.test, tester); // false
tester.tests;                    // 4
 
items.some(null);                // TypeError
items.some(undefined);           // TypeError
items.some({});                  // TypeError

forEach

(interpretuje: Internet Explorer 9, Firefox, Opera, Chrome)

Array.prototype.forEach(callbackfn)
Array.prototype.forEach(callbackfn, thisArg)
Parametry:
Function callbackfn - funkcja zwrotna przyjmująca argumenty:
  • kValue - element tablicy
  • Number k - indeks elementu tablicy
  • Array O - oryginalna tablica
thisArg - wartość bieżącego obiektu this dostępnego w czasie wywołania wewnątrz ciała funkcji (domyślnie: undefined)
Wyjątki:
TypeError - callbackfn nie jest funkcją

Pozwala przejrzeć kolejno wszystkie elementy tablicy. Elementy, które nie zostały jawnie dodane do tablicy, są pomijane.

Nie ma możliwości przerwania w rozsądny sposób przeglądania tablicy przed jej końcem. W takim przypadku lepiej użyć pętli for albo ewentualnie funkcji Array.prototype.some bądź Array.prototype.every.

Przykład:

var items = [3, 2, 1];
 
var sum = 0;
var f = function (x) {
    sum += x;
};
items.forEach(f);
sum;                      // 6;
 
var GreaterThan = function (value) {
    this.value = value;
    this.tests = 0;
    this.sum = 0;
};
GreaterThan.prototype.test = function (value) {
    ++this.tests;
    if (value > this.value) {
        this.sum += value;
        return true;
    }
    return false;
};
 
var tester = new GreaterThan(0);
items.forEach(tester.test, tester);
tester.sum;               // 6
 
tester = new GreaterThan(1);
items.forEach(tester.test, tester);
tester.sum;               // 5
 
// Przerwanie pętli w trakcie:
tester = new GreaterThan(2);
items.every(tester.test, tester);
tester.sum;               // 3
tester.tests;             // 2
 
items = [1, 2];
items[3] = 3;
items.length;             // 4
tester = new GreaterThan(0);
items.forEach(tester.test, tester);
tester.sum;               // 6
tester.tests;             // 3
 
items[2] = undefined;
items.length;             // 4
tester = new GreaterThan(0);
items.forEach(tester.test, tester);
tester.sum;               // 6
tester.tests;             // 4
 
items.forEach(null);      // TypeError
items.forEach(undefined); // TypeError
items.forEach({});        // TypeError

map

(interpretuje: Internet Explorer 9, Firefox, Opera, Chrome)

Array.prototype.map(callbackfn)
Array.prototype.map(callbackfn, thisArg)
Parametry:
Function callbackfn - funkcja zwracająca nową wartość elementu i przyjmująca argumenty:
  • kValue - element tablicy
  • Number k - indeks elementu tablicy
  • Array O - oryginalna tablica
thisArg - wartość bieżącego obiektu this dostępnego w czasie wywołania wewnątrz ciała funkcji (domyślnie: undefined)
Wartość:
Array - nowa tablica
Wyjątki:
TypeError - callbackfn nie jest funkcją

Pozwala przekształcić jedną tablicę w drugą, wykonując na każdym jej elemencie określoną funkcję. Elementy, które nie zostały jawnie dodane do tablicy, są pomijane. Nie zmienia oryginalnej tablicy, ale zwraca nową.

Przykład:

var items = [3, 2, 1];
 
var f = function (x) {
    return -x;
};
items.map(f);                   // [-3, -2, -1]
items;                          // [3, 2, 1]
 
var GreaterThan = function (value) {
    this.value = value;
    this.tests = 0;
};
GreaterThan.prototype.test = function (value) {
    ++this.tests;
    return value > this.value ? -value : value;
};
 
tester = new GreaterThan(1);
items.map(tester.test, tester); // [-3, -2, 1]
 
items = [1, 2];
items[3] = 3;
items.length;                   // 4
tester = new GreaterThan(0);
items.map(tester.test, tester); // [-1, -2, undefined, -3]
tester.tests;                   // 3
 
items[2] = undefined;
items.length;                   // 4
tester = new GreaterThan(0);
items.map(tester.test, tester); // [-1, -2, undefined, -3]
tester.tests;                   // 4
 
items.map(null);                // TypeError
items.map(undefined);           // TypeError
items.map({});                  // TypeError

filter

(interpretuje: Internet Explorer 9, Firefox, Opera, Chrome)

Array.prototype.filter(callbackfn)
Array.prototype.filter(callbackfn, thisArg)
Parametry:
Function callbackfn - funkcja testująca przyjmująca argumenty:
  • kValue - element tablicy
  • Number k - indeks elementu tablicy
  • Array O - oryginalna tablica
thisArg - wartość bieżącego obiektu this dostępnego w czasie wywołania wewnątrz ciała funkcji (domyślnie: undefined)
Wartość:
Array - nowa tablica
Wyjątki:
TypeError - callbackfn nie jest funkcją

Pozwala pobrać z tablicy elementy, które spełniają określony warunek. Elementy, które nie zostały jawnie dodane do tablicy, są pomijane. Nie zmienia oryginalnej tablicy, ale zwraca nową.

Przykład:

var items = [3, 2, 1];
 
var f = function (x) {
    return x > 1;
};
items.filter(f);                   // [3, 2]
items;                             // [3, 2, 1]
 
var GreaterThan = function (value) {
    this.value = value;
    this.tests = 0;
};
GreaterThan.prototype.test = function (value) {
    ++this.tests;
    return value > this.value;
};
 
tester = new GreaterThan(2);
items.filter(tester.test, tester); // [3]
tester.tests;                      // 3
 
items = [1, 2];
items[3] = 3;
items.length;                      // 4
tester = new GreaterThan(0);
items.filter(tester.test, tester); // [1, 2, 3]
tester.tests;                      // 3
 
items[2] = undefined;
items.length;                      // 4
tester = new GreaterThan(0);
items.filter(tester.test, tester); // [1, 2, 3]
tester.tests;                      // 4
 
items.filter(null);                // TypeError
items.filter(undefined);           // TypeError
items.filter({});                  // TypeError

reduce

(interpretuje: Internet Explorer 9, Firefox, Opera 10.50, Chrome)

Array.prototype.reduce(callbackfn)
Array.prototype.reduce(callbackfn, initialValue)
Parametry:
Function callbackfn - funkcja zwracająca zredukowaną wartość i przyjmująca argumenty:
  • accumulator - dotychczasowa zredukowana wartość
  • kValue - element tablicy
  • Number k - indeks elementu tablicy
  • Array O - oryginalna tablica
initialValue - wartość początkowa (domyślnie: element o najniższym indeksie jawnie dodanym do tablicy)
Wartość:
zredukowana wartość tablicy
Wyjątki:
TypeError - callbackfn nie jest funkcją albo nie podano initialValue podczas gdy do tablicy nie dodano jawnie żadnych elementów

Przechodzi kolejno przez wszystkie elementy tablicy, redukując ją do pojedynczej wartości. Elementy, które nie zostały jawnie dodane do tablicy, są pomijane.

Pozwala obliczyć np. silnię lub sumę wszystkich elementów tablicy.

Przykład:

var items = [3, 2, 1];
 
var f = function (a, x) {
    a += x;
    return a;
};
items.reduce(f, 0);      // 6
 
var GreaterThan = function (value) {
    this.value = value;
    this.tests = 0;
};
GreaterThan.prototype.test = function (sum, value) {
    ++this.tests;
    if (value > this.value) sum += value;
    return sum;
};
 
tester = new GreaterThan(1);
f = tester.test.bind(tester);
items.reduce(f);         // 5
tester.tests;            // 2
 
tester = new GreaterThan(1);
f = tester.test.bind(tester);
items.reduce(f, 0);      // 5
tester.tests;            // 3
 
items = [1, 2];
items[3] = 3;
items.length;            // 4
tester = new GreaterThan(0);
f = tester.test.bind(tester);
items.reduce(f, 0);      // 6
tester.tests;            // 3
 
items[2] = undefined;
items.length;            // 4
tester = new GreaterThan(0);
f = tester.test.bind(tester);
items.reduce(f, 0);      // 6
tester.tests;            // 4
 
items.reduce(null);      // TypeError
items.reduce(undefined); // TypeError
items.reduce({});        // TypeError
[].reduce(f);            // TypeError
new Array(3).reduce(f);  // TypeError

reduceRight

(interpretuje: Internet Explorer 9, Firefox, Opera 10.50, Chrome)

Array.prototype.reduceRight(callbackfn)
Array.prototype.reduceRight(callbackfn, initialValue)

Działa analogicznie jak funkcja Array.prototype.reduce, ale przechodzi elementy tablicy w kierunku jej początku, a nie końca.