Diese Übersetzung ist unvollständig. Bitte helfen Sie, diesen Artikel aus dem Englischen zu übersetzen.

Einleitung

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

Syntax

[element0, element1, ..., elementN]
new Array(element0, element1[, ...[, elementN]])
new Array(arrayLength)
elementN
Ein JavaScript array wird initialisiert mit gegebenen Elementen. Ausgenommen im Fall, wenn eine Nummer als einzelnes Argument dem Array Konstrukteur gegeben wird (siehe oben). Beachte, dass dieser Sonderfall nur bei JavaScript Arrays eintritt, die mit dem Array Konstrukteur 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 Konstrukteur als Arugment 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 nicht 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. Weder die Länge noch der Typ eines JavaScript Array ist fix - also veränderbar. Weil die Array Länge zu- oder abnehmen kann, sind JavaScript Arrays nicht immer solide. Grundsätzlich sind das angenehme Charakteristiken; aber wenn diese Features deinen Anforderungen nicht entsprechen, kannst du überlegen typisierte Arrays zu verwenden.

Einige Leute denken, dass man ein Array nicht als assoziatives Array verwenden sollte. In jedem Fall kannst du ein schlichtes objects anstelle benutzen, dabei hat es seine eigenen Ansprüche. Schau dir als Beispiel Lightweight JavaScript dictionaries with arbitrary keys an.

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.

var arr = ['this is the first element', 'this is the second element'];
console.log(arr[0]);              // prints 'this is the first element'
console.log(arr[1]);              // prints 'this is the second element'
console.log(arr[arr.length - 1]); // prints 'this is the second 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 ein 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);   // ergibt ein Syntax Error
console.log(years[0]);  // läuft ordentlich
renderer.3d.setTexture(model, 'character.png');     // ergibt ein Syntax Error
renderer['3d'].setTexture(model, 'character.png');  // läuft ordentlich

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 wird bei '2' und '02'zwei verschiedene Speicherplätze im years Objekt referenziert, und das folgende Beispiel ist true:

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

Ebenfalls können Objekt Eigenschaften, welche mit einem reserviertem Wort(!) versehen sind, nur mit einer Literal Notation in eckigen Klammern angesprochen werden: 

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

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

Beziehung zwischen Längen- und Nummerischen-Eigenschaften

Die JavaScript Array Längen Eigenschaft length und eine nummerische Eigenschaft sind verbunden. Einige der eingebauten Array Methoden (z.B. join, slice, indexOf, etc.) haben Einfluss auf den Wert der Array Längen length Eigenschaft, wenn diese aufgerufen werden. Andere Methoden (z.B.  push, splice, etc.) bewirken ebenfalls 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 ist außerhalb der vorhandenen Array Größe, wird die engine die Array Längen Eigenschaft length 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 Elemete 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-basiertem 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 Teilzeicheketten ist unlimitiert.

 

[1]: bB
[2]: d

Eigenschaften

For properties available on Array instances, see Properties of Array instances.
Array.length
Die Array Konstrukteur Längen-Eigenschaft wessen Wert 1 ist.
Array.prototype
Erlaubt das hinzufügen von Eigenschaften zu allen Array-Objekten.
Properties inherited from Function:

Methoden

For methods available on Array instances, see Methods of Array instances.
Array.from()
Erstellt eine neue Array Instanz von einem Array-ähnlichen oder zählbaren Objekt.
Array.isArray()
Wenn die Variabel 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 eiens Array-Konstrukteurs kann ebenfalls verändert werden, dessen Auswirkung alle Array Instanzen betrifft.

Eigenschaften

Array.prototype.constructor
Specifies the function that creates an object's prototype.
Array.prototype.length
Reflects the number of elements in an array.
Array.prototype[@@unscopables]
A symbol containing property names to exclude from a with binding scope.

Methoden

Mutation-Methoden

These methods modify the array:

Array.prototype.copyWithin()
Copies a sequence of array elements within the array.
Array.prototype.fill()
Fills all the elements of an array from a start index to an end index with a static value.
Array.prototype.pop()
Removes the last element from an array and returns that element.
Array.prototype.push()
Adds one or more elements to the end of an array and returns the new length of the array.
Array.prototype.reverse()
Reverses the order of the elements of an array in place — the first becomes the last, and the last becomes the first.
Array.prototype.shift()
Removes the first element from an array and returns that element.
Array.prototype.sort()
Sorts the elements of an array in place and returns the array.
Array.prototype.splice()
Adds and/or removes elements from an array.
Array.prototype.unshift()
Adds one or more elements to the front of an array and returns the new length of the array.

Zugriff-Methoden

These methods do not modify the array and return some representation of the array.

Array.prototype.concat()
Returns a new array comprised of this array joined with other array(s) and/or value(s).
Array.prototype.includes()
Determines whether an array contains a certain element, returning true or false as appropriate.
Array.prototype.indexOf()
Returns the first (least) index of an element within the array equal to the specified value, or -1 if none is found.
Array.prototype.join()
Joins all elements of an array into a string.
Array.prototype.lastIndexOf()
Returns the last (greatest) index of an element within the array equal to the specified value, or -1 if none is found.
Array.prototype.slice()
Extracts a section of an array and returns a new array.
Array.prototype.toSource()
Returns an array literal representing the specified array; you can use this value to create a new array. Overrides the Object.prototype.toSource() method.
Array.prototype.toString()
Returns a string representing the array and its elements. Overrides the Object.prototype.toString() method.
Array.prototype.toLocaleString()
Returns a localized string representing the array and its elements. Overrides the Object.prototype.toLocaleString() method.

Zähl-Methoden

Several methods take as arguments functions to be called back while processing the array. When these methods are called, the length of the array is sampled, and any element added beyond this length from within the callback is not visited. Other changes to the array (setting the value of or deleting an element) may affect the results of the operation if the method visits the changed element afterwards. While the specific behavior of these methods in such cases is well-defined, you should not rely upon it so as not to confuse others who might read your code. If you must mutate the array, copy into a new array instead.

Array.prototype.entries()
Returns a new Array Iterator object that contains the key/value pairs for each index in the array.
Array.prototype.every()
Returns true if every element in this array satisfies the provided testing function.
Array.prototype.filter()
Creates a new array with all of the elements of this array for which the provided filtering function returns true.
Array.prototype.find()
Returns the found value in the array, if an element in the array satisfies the provided testing function or undefined if not found.
Array.prototype.findIndex()
Returns the found index in the array, if an element in the array satisfies the provided testing function or -1 if not found.
Array.prototype.forEach()
Calls a function for each element in the array.
Array.prototype.keys()
Returns a new Array Iterator that contains the keys for each index in the array.
Array.prototype.map()
Creates a new array with the results of calling a provided function on every element in this array.
Array.prototype.reduce()
Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value.
Array.prototype.reduceRight()
Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value.
Array.prototype.some()
Returns true if at least one element in this array satisfies the provided testing function.
Array.prototype.values()
Returns a new Array Iterator object that contains the values for each index in the array.
Array.prototype[@@iterator]()
Returns a new Array Iterator object that contains the values for each index in the array.

Array generische Methoden

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.

Dies ist momentan kein Teil des ECMAScript-Standards (obwohl das ES2015 Array.from() genutzt werden kann um das zu erreichen). Die folgende Übergangslösung kann in allen Browsern genutzt werden:

// Assumes Array extras already present (one may use polyfills for these as well)
(function() {
  'use strict';

  var i,
    // We could also build the array of methods with the following, but the
    //   getOwnPropertyNames() method is non-shimable:
    // Object.getOwnPropertyNames(Array).filter(function(methodName) {
    //   return typeof Array[methodName] === 'function'
    // });
    methods = [
      'join', 'reverse', 'sort', 'push', 'pop', 'shift', 'unshift',
      'splice', 'concat', 'slice', 'indexOf', 'lastIndexOf',
      'forEach', 'map', 'reduce', 'reduceRight', 'filter',
      'some', 'every'
    ],
    methodCount = methods.length,
    assignArrayGeneric = function(methodName) {
      if (!Array[methodName]) {
        var method = Array.prototype[methodName];
        if (typeof method === 'function') {
          Array[methodName] = function() {
            return method.call.apply(method, arguments);
          };
        }
      }
    };

  for (i = 0; i < methodCount; i++) {
    assignArrayGeneric(methods[i]);
  }
}());

Beispiele

Beispiel: 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.');
}

Beispiel: 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

Spezifikationen

Spezifikation Status Kommentar
ECMAScript 1st Edition. Standard Initial definition.
ECMAScript 5.1 (ECMA-262)
Die Definition von 'Array' in dieser Spezifikation.
Standard New methods added: 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 New methods added: Array.from, Array.of, find, findIndex, fill, copyWithin

Browserkompabilität

Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari
Basic support (Ja) (Ja) (Ja) (Ja) (Ja)
Feature Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Basic support (Ja) (Ja) (Ja) (Ja) (Ja) (Ja)

Siehe auch

Schlagwörter des Dokuments und Mitwirkende

Schlagwörter: 
 Mitwirkende an dieser Seite: Eiknheimer, StevenS77, kdex, antonharald, fscholz, Airblader
 Zuletzt aktualisiert von: Eiknheimer,