Przejdź do treści

Operacje na tablicach w JavaScript - Array.prototype

W jaki sposób operować na tablicach w języku JavaScript?

Konstruktor tablicy - constructor

Gdzie jest zapisany konstruktor tablicy?

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

Zawiera wbudowany konstruktor obiektu Array.

Przykład Array.prototype.constructor

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

Przekształcanie tablicy na tekst - toString

Jak przekształcić tablicę elementów na prosty tekst?

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 Array.prototype.toString

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

Przekształcanie tablicy na tekst w rodzimym języku - toLocaleString

Jak przekształcić tablicę elementów na tekst zapisany w rodzimym języku użytkownika?

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 Array.prototype.toLocaleString

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

Łączenie tablic - concat

W jaki sposób połączyć dwie tablice w jedną?

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 Array.prototype.concat

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]

Przekształcanie tablicy na tekst z separatorem - join

W jaki sposób przekształcić tablicę na tekst, w którym kolejne elementy będą oddzielone od siebie określonym separatorem?

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 Array.prototype.join

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

Usuwanie ostatniego elementu z tablicy - pop

Jak usunąć ostatni element z tablicy?

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 Array.prototype.pop

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

Dodawanie elementu na końcu tablicy - push

Jak dodać nowy element na końcu tablicy?

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 Array.prototype.push

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]]

Odwracanie kolejności elementów w tablicy - reverse

W jaki sposób odwrócić kolejność elementów w tablicy?

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 Array.prototype.reverse

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

Usuwanie pierwszego elementu z tablicy - shift

Jak usunąć pierwszy element z tablicy?

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 Array.prototype.shift

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

Wycinanie części elementów tablicy - slice

W jaki sposób wyciąć część elementów tablicy?

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 Array.prototype.slice

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]

Sortowanie elementów tablicy - sort

Jak posortować elementy tablicy w porządku alfabetycznym?

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 Array.prototype.sort

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"}]

Wycinanie i zastępowanie elementów tablicy - splice

W jaki sposób wyciąć część elementów tablicy i zastąpić je innymi?

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 Array.prototype.splice

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]

Dodawanie elementu na początku tablicy - unshift

Jak dodać nowy element na początku tablicy?

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 Array.prototype.unshift

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]

Sprawdzanie obecności elementu w tablicy - indexOf

Jak sprawdzić, czy w tablicy występuje określony elementy?

(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 Array.prototype.indexOf

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

Przeszukiwanie tablicy od końca - lastIndexOf

Jak przeszukać tablicę od końca, tak by sprawdzić, czy znajduje się w niej określony element?

(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 Array.prototype.lastIndexOf

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

Sprawdzanie warunku dla wszystkich elementów - every

Jak sprawdzić, czy wszystkie elementy tablicy spełniają podany warunek?

(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 Array.prototype.every

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

Sprawdzanie warunku dla przynajmniej jednego elementu - some

Jak sprawdzić, czy przynajmniej jeden element tablicy spełnia podany warunek?

(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 Array.prototype.some

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

Iterowanie po elementach tablicy - forEach

W jaki sposób przejść kolejno po wszystkich elementach tablicy?

(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 Array.prototype.forEach

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

Przekształcanie elementów tablicy - map

W jaki sposób przekształcić wszystkie elementy tablicy?

(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 Array.prototype.map

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

Odfiltrowywanie elementów tablicy - filter

W jaki sposób odfiltrować elementy tablicy, które nie spełniają podanego warunku?

(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 Array.prototype.filter

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

Redukowanie tablicy do wartości - reduce

Jak zredukować tablicę do pojedynczej prostej wartości?

(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 Array.prototype.reduce

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

Wsteczne redukowanie tablicy - reduceRight

Jak wstecznie zredukować tablicę do pojedynczej prostej wartości?

(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.

Facebook