Das JavaScript Array ist ein globales Objekt und Konstruktor für das Erstellen von Arrays, welche listenähnliche Objekte sind.

Ein Array erstellen

var fruits = ['Apple', 'Banana'];

console.log(fruits.length);
// 2

Zugriff auf ein Arrayelement (mit Index)

var first = fruits[0];
// Apple

var last = fruits[fruits.length - 1];
// Banana

Über ein Array Iterieren

fruits.forEach(function(item, index, array) {
  console.log(item, index);
});
// Apple 0
// Banana 1

Ein Element am Ende des Arrays einfügen

var newLength = fruits.push('Orange');
// ["Apple", "Banana", "Orange"]

Ein Element am Ende des Arrays löschen

var last = fruits.pop(); // remove Orange (from the end)
// ["Apple", "Banana"];

Ein Element am Anfang des Arrays löschen

var first = fruits.shift(); // remove Apple from the front
// ["Banana"];

Ein Element am Anfang des Arrays einfügen

var newLength = fruits.unshift('Strawberry') // add to the front
// ["Strawberry", "Banana"];

Den Index eines Elements im Array ermitteln.

fruits.push('Mango');
// ["Strawberry", "Banana", "Mango"]

var pos = fruits.indexOf('Banana');
// 1

Ein Element mithilfe eines Index aus dem Arrays löschen

var removedItem = fruits.splice(pos, 1); // this is how to remove an item
                                        
// ["Strawberry", "Mango"]

Elemente von einer Indexposition aus löschen

var vegetables = ['Cabbage', 'Turnip', 'Radish', 'Carrot'];
console.log(vegetables); 
// ["Cabbage", "Turnip", "Radish", "Carrot"]

var pos = 1, n = 2;

var removedItems = vegetables.splice(pos, n); 
// this is how to remove items, n defines the number of items to be removed,
// from that position(pos) onward to the end of array.

console.log(vegetables); 
// ["Cabbage", "Carrot"] (the original array is changed)

console.log(removedItems); 
// ["Turnip", "Radish"]

Ein Array kopieren

var shallowCopy = fruits.slice(); // this is how to make a copy
// ["Strawberry", "Mango"]

Syntax

[element0, element1, ..., elementN]
new Array(element0, element1[, ...[, elementN]])
new Array(arrayLength)

Parameter

elementN
Ein JavaScript-Array wird mit gegebenen Elementen initialisiert. Ausgenommen im Falle, dass eine Nummer als einzelnes Argument dem Array-Konstruktor gegeben wird (siehe oben). Beachte, dass dieser Sonderfall nur bei JavaScript-Arrays eintritt, die mit dem Array-Konstruktor erstellt wurden - nicht bei erstellten Array-Literalen, welche mit der Eckigen-Klammer-Syntax erstellt wurden.
arrayLength
Wenn nur eine ganzzahlige Zahl zwischen 0 und 232-1 (inklusive) dem Array-Konstruktor als Argument gegeben wird, ergibt der Rückgabewert ein neues Javascript-Array mit der Länge der angegebenen Nummer. Wenn das Argument irgendeine andere Nummer ist (also kein Integer-Wert), tritt die Fehlermeldung RangeError auf.

Beschreibung

Arrays sind listenähnliche Objekte, dessen Prototypen Methoden haben, welche übergreifende Operationen und Mutationen ausführen können. Sowohl die Länge, als auch die Typen der Elemente eines JavaScript Arrays sind veränderbar. Weil die Arraylänge zu jeder Zeit geändert werden kann und Objekte an jedem Index im Array gespeichert werden können, ist ein JavaScript Arrays nicht immer solide. Es hängt davon ab, wie der Programmierer diese Möglichkeiten benutzt. Grundsätzlich sind das angenehme Charakteristiken; aber wenn diese Features deinen Anforderungen nicht entsprechen, kannst du überlegen, typisierte Arrays zu verwenden.

Arrays können keine Strings als Index benutzen werden (wie bei assoziativen Arrays), sondern müssen Integers sein. Setzen oder Lesen mit nicht-Integers bei der Klammernotation (oder Punktnotation) haben keinen direkten Zugriff auf das Array selber, aber setzen oder lesen die Variablen, der ArrayeIgenschaften. Die liste der Array Eigenschaften und die liste der Elemente in einem Array sind getrennt und die Operationen zu Ändern und Traversieren auf einem Array können nicht auf diese Eigenschaftsnamen zugreifen.

Zugriff auf Array-Elemente

JavaScript-Arrays sind null-indiziert: das erste Element eines Arrays startet beim Index 0, und das letzte Element hat den Index der Menge der Elemente length im Array minus 1. Ein nicht valider Index gibt undefined zurück.

var arr = ['Das erste Element', 'Das zweite Element'];
console.log(arr[0]);              // Output: 'Das erste Element'
console.log(arr[1]);              // Output: 'Das zweite Element'
console.log(arr[arr.length - 1]); // Output: 'Das zweite Element'

Array-Elemente sind Objekt-Eigenschaften im gleichen Maße, wie toString eine Eigenschaft ist. Aber beim Zugriff auf ein Element eines Arrays gibt es einen Syntax-Error, weil der Name der Eigenschaft nicht valide ist.

console.log(arr.0);

Es gibt nichts Besonderes über JavaScript-Arrays und die Eigenschaften, die das verursachen. JavaScript-Eigenschaften, die mit einer Nummer beginnen, können nicht mit einer Punkt-Notation referenziert werden und müssen Mithilfer der Eckigen-Klammer-Notation angesprochen werden. Ein Beispiel: wenn du ein Objekt namens '3d' hast, kannst du es nur mit der eckigen Klammer referenzieren. Siehe:

var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
console.log(years.0);   // Ein SyntaxError
console.log(years[0]);  // Funktioniert
renderer.3d.setTexture(model, 'character.png');     // Ein SyntaxError
renderer['3d'].setTexture(model, 'character.png');  // Funktioniert

Bemerke, dass im 3d-Beispiel das '3d' in Anführungszeichen stehen muss. Es ist möglich den Index des JavaScript-Arrays ebenfalls in Anführungszeichen zu setzen (z. B. years['2'] anstelle von years[2]), obwohl es nicht nötig ist. Die 2 in years[2] wird von der JavaScript-Engine von der implizierten Typkonvertierung (toString) in einen String umgewandelt. Aus diesem Grund werden bei '2' und '02' zwei verschiedene Speicherplätze im years-Objekt referenziert, und das folgende Beispiel ist true:

console.log(years['2'] != years['02']);

Genauso können Objekteigenschaften, welche mit einem reserviertem Wort(!) versehen sind, nur mit der Literal-Notation in eckigen Klammern erreicht werden (man hat seit Firefox 40.0a2 auch durch Punktnotation Zugegriff):

var promise = {
  'var'  : 'text',
  'array': [1, 2, 3, 4]
};

console.log(promise['array']);

Beziehung zwischen length und numerischen Eigenschaften

Die JavaScript-Array-Längen-Eigenschaft length und eine numerische Eigenschaft sind verbunden. Einige der eingebauten Array-Methoden (z. B. join, slice, indexOf, etc.) haben Einfluss auf den Wert der Array-Längen-Eigenschaft length, wenn diese aufgerufen werden. Andere Methoden (z. B. push, splice, etc.) bewirken ebenfalls eine Veränderung in der Längen-Eigenschaft length eines Arrays.

var fruits = [];
fruits.push('banana', 'apple', 'peach');

console.log(fruits.length); // 3

Beim Setzen einer Eigenschaft auf ein JavaScript-Array - wenn es sich um einen validen Array-Index handelt und der Index außerhalb der vorhandenen Arraygröße ist, wird JavaScript die length Eigenschaft des Arrays dementsprechend aktualisieren.

fruits[5] = 'mango';
console.log(fruits[5]); // 'mango'
console.log(Object.keys(fruits));  // ['0', '1', '2', '5']
console.log(fruits.length); // 6

Erhöhung der Länge length.

fruits.length = 10;
console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
console.log(fruits.length); // 10

Verkleinerung der length Längen-Eigenschaft bewirkt eine Löschung von Elementen.

fruits.length = 2;
console.log(Object.keys(fruits)); // ['0', '1']
console.log(fruits.length); // 2

Dies wird genauer auf der Seite Array.length erklärt.

Erstellen eines Arrays als Resultat einer Übereinstimmung

Das Resultat einer Übereinstimmung eines regulären Ausdrucks und einem String kann ein JavaScript-Array erstellen. Dieses Array hat Eigenschaften und Elemente, welche Informationen über die Übereinstimmung beinhalten. Solch ein Array wird ausgegeben von RegExp.exec, String.match und String.replace. Als Hilfe, um die Eigenschaften und Elemente zu verstehen, kannst du dir das folgende Beispiel mit der der Tabelle unterhalb vergleichen:

// Übereinstimmung eines d gefolgt von einem oder mehr b's gefolgt von einem d
// Merke übereinstimmende b's und das folgende d
// Ignoriere Fall

var myRe = /d(b+)(d)/i;
var myArray = myRe.exec('cdbBdbsbz');

Die Eigenschaften und Elemente werden wie folgt zurückgegeben:

Eigenschaft/Element Beschreibung Beispiel
input

Eine Nur-lesen-Eigenschaft, welche die Übereinstimmung des Original-Strings mit einem regulären Ausdruck ausgibt.

cdbBdbsbz
index Eine Nur-lesen-Eigenschaft mit einem null-basierten Index der Übereinstimmung in dem String. 1
[0] Ein Nur-lesen-Element, welches die übereinstimmenden Zeichen wiedergibt. dbBd
[1], ...[n] Ein Nur-lesen-Element, welches die eingeklammerte Teilzeichenkette (von - bis) als Übereinstimmung zurückgibt - wenn regulärer Ausdruck. Die Länge der Teilzeichenketten ist unlimitiert. [1]: bB
[2]: d

Eigenschaften

Array.length
Die length Eigenschaft des Array Konstruktors ist 1.
get Array[@@species]
Die Konstruktorfunktion die für abgeleitete Objekte benutzt wird.
Array.prototype
Erlaubt das Hinzufügen von Eigenschaften zu allen Array-Objekten.

Methoden

Array.from()
Erstellt eine neue Array-Instanz von einem Array-ähnlichen oder zählbaren Objekt.
Array.isArray()
Wenn die Variable ein Array ist, gibt der Rückgabewert true aus, ansonsten false.
Array.of()
Erstellt eine neue Array-Instanz mit einer variablen Anzahl an Argumenten, unbeachtet der Anzahl oder des Typs der Argumente.

Array Instanzen

Alle Array-Instanzen erben vom Array.prototype. Das Prototyp-Objekt eines Array-Konstruktors kann ebenfalls verändert werden, dessen Auswirkung alle Array-Instanzen betrifft.

Eigenschaften

Array.prototype.constructor
Beschreibt die Funktion um ein Objekt-Prototypen zu erstellen.
Array.prototype.length
Gibt die Nummer an Elementen in einem Array wieder.
Array.prototype[@@unscopables]
Eine Symbol-beinhaltende Eigenschaft beschreibt das ausschließen von einem mit with eingebundenden Geltungsbereich.

Methoden

Mutationsmethoden

Diese Methoden verändern ein Array:

Array.prototype.copyWithin()
Kopiert einen Teil eines Array Elements innerhalb eines Array.
Array.prototype.fill()
Füllt alle Elemente eines Arrays von einem Start-Index zu einem Ende-Index mit einem festen Wert.
Array.prototype.pop()
Entfernt das letzte Element von einem Array und gibt dieses Element als Rückgabewert aus.
Array.prototype.push()
Fügt eins oder mehrere Elemente zu dem Ende des Arrays hinzu und gibt die neue Länge des Arrays zurück
Array.prototype.reverse()
Dreht die Reihenfolge der Elemente in einem Array um - das erste Element wird das letzte und das letzte Element wird das erste.
Array.prototype.shift()
Entfernt das erste Element innerhalb eines Array und gibt das Element als Rückgabewert aus.
Array.prototype.sort()
Sortiert innerhalb eines Arrays die Elemente und gibt das sortierte Array aus.
Array.prototype.splice()
Fügt Elemente von einem Array hinzu und/oder entfernt diese.
Array.prototype.unshift()
Fügt ein oder mehr Elemente an erster Stelle eines Array hinzu und gibt die Länge des neuen Arrays zurück.

Zugriffsmethoden

Diese Methoden verändern das Array nicht und geben als Rückgabewert eine Darstellung des Arrays an.

Array.prototype.concat()
Gibt ein neues Array zusammengestellt von diesem Array und verknüpft mit anderen/ mehreren Array(s) und/ oder einem/ mehreren Wert(en).
Array.prototype.includes()
Überprüft, ob ein Array ein bestimmtes Element enthält und gibt als Rückgabewert true oder false an.
Array.prototype.indexOf()
Gibt die erste Stelle (Index) eines einzelnen, dem beschriebenen, Elements innerhalb eines Array an. Wenn das Element nicht gefunden wurde gibt er -1 zurück.
Array.prototype.join()
Verbindet alle Elemente eines Arrays zu einem String.
Array.prototype.lastIndexOf()
Gibt den letzten (höchsten) Index des beschriebenen Elements innerhalb eines Arrays aus, oder -1, wenn nichts gefunden wurde.
Array.prototype.slice()
Extrahiert einen Teil eines Arrays und gibt diesen als neues Array aus.
Array.prototype.toSource()
Gibt ein Array-Literal des beschriebenen Arrays zurück; du kannst diesen Wert nutzen um ein neues Array zu erstellen. Überschreibt die Object.prototype.toSource() Methode.
Array.prototype.toString()
Gibt einen String zurück, welcher das Array und seine Elemente beinhaltet. Überschreibt die Object.prototype.toString() Methode.
Array.prototype.toLocaleString()
Gibt einen lokalen String zurück, welcher das Array und seine Elemente beschreibt. Überschreibt die Object.prototype.toLocaleString() Methode.

Zählmethoden

Einige Methoden nehmen als Argument eine Funktion an und führen diese während des Aufrufs des Arrays aus. Wenn diese Methoden aufgerufen werden, wird die Länge (length) des Arrays abgetastet und jedes Element außerhalb der dieser Länge innerhalb eines nicht aufgerufenen Callbacks hinzugefügt. Andere Änderungen zu einem Array (setzen eines Wertes oder das Löschen eines Elements) könnten Auswirkungen auf das Ergebnis der Operation haben, wenn die Methode das veränderte Element im Nachhinein besucht. Während das spezielle Verhalten dieser Methoden in einem solchen Fall gut definiert sind, solltest du dich dennoch nicht darauf verlassen, damit du andere, die deinen möglicherweise lesen - nicht verwirrt werden. Wenn du das Array verändern musst, solltest du das veränderte Array in ein neu erstelltes Array packen.

Array.prototype.entries()
Gibt ein neues Array Zähl Objekt (Array Iterator Object) zurück, welches das key/value Paar für jeden Index in dem Array innehält.
Array.prototype.every()
Gibt true zurück, wenn alle Elemente in diesem Array die zu testende Funktion bestehen.
Array.prototype.filter()
Erstellt ein neues Array mit allen Elementen dieses Arrays für welches die Filter-Funktion innerhalb den Rückgabewert true benutzt.
Array.prototype.find()
Gibt den ersten gefundenen Wert innerhalb eines Arrays wieder, wenn ein Element innerhalb des Arrays die definierte Test-Funktion besteht oder undefined wenn nichts gefunden wurde.
Array.prototype.findIndex()
Gibt den gefundenen Index im Array an, wenn ein Element in dem Array die angegebene Test-Funktion besteht - oder -1, wenn nichts gefunden wurde.
Array.prototype.forEach()
Ruft eine Funktion für jedes Element in einem Array auf.
Array.prototype.keys()

Gibt einen neuen Array Iterator (Zeiger) aus, welcher die Schlüssel für jeden Index innerhalb des Arrays beinhaltet.

Array.prototype.map()
Erstellt ein neues Array mit den Ergebnissen der ausgeführten definierten Funktion an jedem Element in diesem Array.
Array.prototype.reduce()
Reduziert das Array auf einen einzigen Wert, indem es jeweils zwei Elemente durch die angegebene Funktion ausführt. Optional: als zweiten Paramater einen Startwert angeben.
Array.prototype.reduceRight()
Reduziert das Array auf einen einzigen Wert, indem es jeweils zwei Elemente durch die angegebene Funktion ausführt (von rechts nach links). Optional: als zweiten Paramater einen Startwert angeben.
Array.prototype.some()
Gibt true zurück, wenn mindestens ein Element in diesem Array den Test der definierten Funktion besteht.
Array.prototype.values()
Gibt einen neues Array Iterator Objekt zurück, welches die Werte für jeden Index in dem Array beinhaltet.
Array.prototype[@@iterator]()
Gibt einen neues Array Iterator Objekt zurück, welches die Werte für jeden Index in dem Array beinhaltet.

Generische Array Methoden

Generische Array Methoden sind nicht standardisiert und veraltet und werden in naher Zukunft entfernt.

Manchmal ist es gewünscht, Array-Methoden auf Strings oder anderen Array-ähnlichen Objekten (wie z.B. function arguments) anzuwenden. Auf diese Weise wird ein String als ein Array von Zeichen behandelt (oder für andere Fälle ganz allgemein: ein Nicht-Array wird als ein Array behandelt). Um beispielsweise zu prüfen, ob jedes Zeichen in der Variable str ein Buchstabe ist, könnte man schreiben:

function isLetter(character) {
  return character >= 'a' && character <= 'z';
}

if (Array.prototype.every.call(str, isLetter)) {
  console.log("The string '" + str + "' contains only letters!");
}

Diese Schreibweise ist weniger sinnvoll, und seit JavaScript 1.6 gibt es eine kürzere Schreibweise:

if (Array.every(str, isLetter)) {
  console.log("The string '" + str + "' contains only letters!");
}

Generics sind ebenfalls verfügbar in String.

Dieses ist kein Teil der ECMAScript-Standards und wird von nicht Gecko Browsern nicht unterstützt. Ein Standardisierte Alternative ist es, ein Objekt zu einem normalen Array mit Array.from() zu konvertieren. Jedoch ist diese Methode in alten Browsern nicht verfügbar:

if (Array.from(str).every(isLetter)) {
  console.log("The string '" + str + "' contains only letters!")
}

Beispiele

Erstellen eines Arrays

Das folgende Beispiel erzeugt ein Array msgArray mit der Länge 0, weist dann msgArray[0] und msgArray[99] Werte zu und ändert somit die Länge des Arrays auf 100.

var msgArray = [];
msgArray[0] = 'Hello';
msgArray[99] = 'world';

if (msgArray.length === 100) {
  console.log('The length is 100.');
}

Erstellen eines zweidimensionalen Arrays

Im Folgenden wird ein Schachbrett als zweidimensionales Array von Strings erzeugt. Der erste Zug erfolgt durch Kopieren des 'p' in (6,4) nach (4,4). Die alte Position (6,4) wird als leer markiert.

var board = [ 
  ['R','N','B','Q','K','B','N','R'],
  ['P','P','P','P','P','P','P','P'],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  ['p','p','p','p','p','p','p','p'],
  ['r','n','b','q','k','b','n','r'] ];

console.log(board.join('\n') + '\n\n');

// Ziehe Bauern 2 Felder vorwärts
board[4][4] = board[6][4];
board[6][4] = ' ';
console.log(board.join('\n'));

Das ist die Ausgabe:

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , , 
 , , , , , , , 
 , , , , , , , 
 , , , , , , , 
p,p,p,p,p,p,p,p
r,n,b,q,k,b,n,r

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , , 
 , , , , , , , 
 , , , ,p, , , 
 , , , , , , , 
p,p,p,p, ,p,p,p
r,n,b,q,k,b,n,r

Einsatz eines Arrays, um Werte geordnet auszugeben

values = [];
for (var x = 0; x < 10; x++){
 values.push([
  2 ** x,
  2 * x ** 2
 ])
};
console.table(values)

Das Resultat ist:

0   1   0
1   2   2
2   4   8
3   8   18
4   16  32
5   32  50
6   64  72
7   128 98
8   256 128
9   512 162

(Die erste Spalte ist der Index)

Spezifikationen

Spezifikation Status Kommentar
ECMAScript 1st Edition. Standard Initiale Definition.
ECMAScript 5.1 (ECMA-262)
Die Definition von 'Array' in dieser Spezifikation.
Standard Neue Methoden hinzugefügt: Array.isArray, indexOf, lastIndexOf, every, some, forEach, map, filter, reduce, reduceRight
ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'Array' in dieser Spezifikation.
Standard Neue Methoden hinzugefügt: Array.from, Array.of, find, findIndex, fill, copyWithin

Browserkompatibilität

FunktionChromeEdgeFirefoxInternet ExplorerOperaSafari
Grundlegende Unterstützung Ja Ja1 Ja Ja Ja
concat1 Ja15.5 Ja Ja
copyWithin451232 Nein329
entries38 Ja28 Nein258
every Ja Ja1.59 Ja Ja
fill45 Ja31 Nein Ja8
filter Ja Ja1.59 Ja Ja
find45 Ja25 Nein328
findIndex45 Ja25 Nein328
flatten Nein Nein Nein1 Nein Nein Nein
flatMap Nein Nein Nein1 Nein Nein Nein
forEach Ja Ja1.59 Ja Ja
from45 Ja32 Nein Ja9
includes471443 Nein349
indexOf Ja Ja1.59 Ja Ja
isArray5 Ja4910.55
join1 Ja15.5 Ja Ja
keys38 Ja28 Nein258
lastIndexOf Ja Ja1.59 Ja Ja
length Ja Ja1 Ja Ja Ja
map Ja Ja1.59 Ja Ja
observe36 — 52 Nein Nein Nein Nein Nein
of45 Ja25 Nein Ja9
pop1 Ja15.5 Ja Ja
prototype Ja Ja1 Ja Ja Ja
push1 Ja15.5 Ja Ja
reduce Ja Ja3910.54
reduceRight Ja Ja3910.54
reverse1 Ja15.5 Ja Ja
shift1 Ja15.5 Ja Ja
slice1 Ja1 Ja Ja Ja
some Ja Ja1.59 Ja Ja
sort1 Ja15.5 Ja Ja
splice1 Ja15.5 Ja Ja
toLocaleString Ja Ja1 Ja Ja Ja
toSource Nein Nein1 Nein Nein Nein
toString Ja Ja1 Ja Ja Ja
unobserve36 — 52 Nein Nein Nein Nein Nein
unshift1 Ja15.5 Ja Ja
values66 Ja60 Nein539
@@iterator38 ?

36

27 — 362 3

17 — 274 5

Nein25 Ja
@@species ? ?48 ? ? ?
@@unscopables ? ?48 ? ? ?
FunktionAndroid webviewChrome for AndroidEdge mobileFirefox for AndroidOpera AndroidiOS SafariSamsung Internet
Grundlegende Unterstützung Ja Ja Ja4 Ja Ja Ja
concat Ja Ja Ja4 Ja Ja Ja
copyWithin Ja Ja Ja32 Ja Ja Ja
entries Ja Ja Ja28 Ja8 Ja
every Ja Ja Ja4 Ja Ja Ja
fill Ja Ja Ja31 Ja8 Ja
filter Ja Ja Ja4 Ja Ja Ja
find Ja Ja Ja4 Ja8 Ja
findIndex Ja Ja Ja4 Ja8 Ja
flatten Nein Nein Nein Nein1 Nein Nein Nein
flatMap Nein Nein Nein Nein1 Nein Nein Nein
forEach Ja Ja Ja4 Ja Ja Ja
from ? Ja Ja32 Ja Ja Ja
includes Ja Ja1443349 Ja
indexOf Ja Ja Ja4 Ja Ja Ja
isArray Ja Ja Ja4 Ja Ja Ja
join Ja Ja Ja4 Ja Ja Ja
keys Ja Ja Ja28 Ja8 Ja
lastIndexOf Ja Ja Ja4 Ja Ja Ja
length Ja Ja Ja4 Ja Ja Ja
map Ja Ja Ja4 Ja Ja Ja
observe Nein Nein Nein Nein Nein Nein Nein
of Ja39 Ja25 Ja Ja4.0
pop Ja Ja Ja4 Ja Ja Ja
prototype Ja Ja Ja4 Ja Ja Ja
push Ja Ja Ja4 Ja Ja Ja
reduce Ja Ja Ja4 Ja Ja Ja
reduceRight Ja Ja Ja4 Ja Ja Ja
reverse Ja Ja Ja4 Ja Ja Ja
shift Ja Ja Ja4 Ja Ja Ja
slice Ja Ja Ja4 Ja Ja Ja
some Ja Ja Ja4 Ja Ja Ja
sort Ja Ja Ja4 Ja Ja Ja
splice Ja Ja Ja4 Ja Ja Ja
toLocaleString Ja Ja Ja4 Ja Ja Ja
toSource Nein Nein Nein4 Nein Nein Nein
toString Ja Ja Ja4 Ja Ja Ja
unobserve Nein Nein Nein Nein Nein Nein Nein
unshift Ja Ja Ja4 Ja Ja Ja
values6666 Ja60539 Nein
@@iterator Ja Ja ?

36

27 — 362 3

17 — 274 5

Ja Ja Ja
@@species ? ? ?48 ? ? ?
@@unscopables ? ? ?48 ? ? ?

1. Available in Firefox Nightly only. See bug 1435813 for status on enabling this by default.

2. A placeholder property named @@iterator is used.

3. Supported as @@iterator.

4. A placeholder property named iterator is used.

5. Supported as iterator.

Siehe auch

Schlagwörter des Dokuments und Mitwirkende

Zuletzt aktualisiert von: schlagi123,