path: root/files/de/web/javascript/reference/global_objects/array/index.html

---
title: Array
slug: Web/JavaScript/Reference/Global_Objects/Array
tags:
  - Array
  - Example
  - Global Objects
  - JavaScript
  - Reference
translation_of: Web/JavaScript/Reference/Global_Objects/Array
---
<div>{{JSRef}}</div>

<p>Das JavaScript-<strong><code>Array</code></strong> ist ein globales Objekt und Konstruktor für das Erstellen von Arrays, welche listenähnliche Objekte sind.</p>

<p><strong>Ein Array erstellen</strong></p>

<pre class="brush: js">var fruits = ['Apple', 'Banana'];

console.log(fruits.length);
// 2
</pre>

<p><strong>Zugriff auf ein Arrayelement (mit Index)</strong></p>

<pre class="brush: js">var first = fruits[0];
// Apple

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

<p><strong>Über ein Array Iterieren</strong></p>

<pre class="brush: js">fruits.forEach(function(item, index, array) {
  console.log(item, index);
});
// Apple 0
// Banana 1
</pre>

<p><strong>Ein Element am Ende des Arrays einfügen</strong></p>

<pre class="brush: js">var newLength = fruits.push('Orange');
// ["Apple", "Banana", "Orange"]
</pre>

<p><strong>Ein Element am Ende des Arrays löschen</strong></p>

<pre class="brush: js">var last = fruits.pop(); // remove Orange (from the end)
// ["Apple", "Banana"];
</pre>

<p><strong>Ein Element am Anfang des Arrays löschen</strong></p>

<pre class="brush: js">var first = fruits.shift(); // remove Apple from the front
// ["Banana"];
</pre>

<p><strong>Ein Element am Anfang des Arrays einfügen</strong></p>

<pre class="brush: js">var newLength = fruits.unshift('Strawberry') // add to the front
// ["Strawberry", "Banana"];
</pre>

<p><strong>Den Index eines Elements im Array ermitteln</strong></p>

<pre class="brush: js">fruits.push('Mango');
// ["Strawberry", "Banana", "Mango"]

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

<p><strong>Ein Element mithilfe eines Index aus dem Array löschen</strong></p>

<pre class="brush: js">var removedItem = fruits.splice(pos, 1); // this is how to remove an item

// ["Strawberry", "Mango"]</pre>

<p><strong>Elemente von einer Indexposition aus löschen</strong></p>

<pre class="brush: js">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"]</pre>

<p><strong>Ein Array kopieren</strong></p>

<pre class="brush: js">var shallowCopy = fruits.slice(); // this is how to make a copy
// ["Strawberry", "Mango"]
</pre>

<h2 id="Syntax" name="Syntax">Syntax</h2>

<pre class="syntaxbox"><code>[<var>element0</var>, <var>element1</var>, ..., <var>elementN</var>]
new Array(<var>element0</var>, <var>element1</var>[, ...[, <var>elementN</var>]])
new Array(<var>arrayLength</var>)</code></pre>

<h3 id="Parameter">Parameter</h3>

<dl>
 <dt><code>element<em>N</em></code></dt>
 <dd>Ein JavaScript-Array wird mit den angegebenen Elementen initialisiert, es sei denn, an den <code>Array</code>-Konstruktor wird eine einzelne Zahl übergeben (siehe <code>arrayLength-</code>Parameter unten). Beachte, dass dieser Sonderfall nur für JavaScript-Arrays gilt, die mit dem <code>Array</code>-Konstruktor erstellt wurden, nicht für Array-Literale, die mit der Klammer-Syntax erstellt wurden.</dd>
 <dt><code>arrayLength</code></dt>
 <dd>Wenn lediglich eine Ganzzahl zwischen 0 und 2<sup>32</sup>-1 (inklusive) als Argument an den <code>Array</code>-Konstruktor übergeben wird, ist der Rückgabewert ein JavaScript Array, dessen <code>length</code>-Eigenschaft dieser Zahl entspricht. (<strong>Hinweis:</strong> Dies impliziert ein Array mit leeren Elementen einer Anzahl von <code>arrayLength</code>, nicht Elementen mit Wert <code>undefined</code>). Handelt es sich bei dem Argument um irgendeine andere Zah,l wird eine {{jsxref("Global_Objects/RangeError", "RangeError")}} Exception ausgelöst.</dd>
</dl>

<h2 id="Description" name="Description">Beschreibung</h2>

<p>Arrays sind listenähnliche Objekte, dessen Prototyp Methoden für Durchlauf- und Mutationsoperationen besitzt. Weder die Länge eines JavaScript-Arrays noch die Typen seiner Elemente sind fix. Da sich die Länge eines Arrays jederzeit ändern kann und Daten an nicht zusammenhängenden Positionen im Array gespeichert werden können, ist nicht garantiert, dass JavaScript-Arrays verdichtet sind; dies hängt davon ab, wie der Programmierer sie benutzt. Im Allgemeinen sind dies praktische Merkmale; falls jedoch diese Funktionalität für Ihren Anwendungsfall nicht wünschenswert ist, sollten Sie in Betracht ziehen, typisierte Arrays zu verwenden.</p>

<p>Arrays können keine Strings als Index benutzen (wie bei<a class="external" href="http://www.andrewdupont.net/2006/05/18/javascript-associative-arrays-considered-harmful/"> assoziativen Arrays</a>), sondern müssen Ganzzahlen verwenden. Der Zugriff mit nicht-ganzzahligen Werten über die <a href="/de/docs/Web/JavaScript/Guide/Mit_Objekten_arbeiten#Objekte_und_Eigenschaften">Klammernotation</a> (oder <a href="/de/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Punktnotation</a>) bezieht sich nicht auf ein Element im Array, sondern legt eine Eigenschaft des Array-Objekts fest oder greift darauf zu. Die Eigenschaften des Array-Objekts und die Liste der Array-Elemente sind voneinander getrennt. Die <a href="/de/docs/Web/JavaScript/Guide/Indexed_collections#Array-Methoden">Durchlauf- und Mutationsoperationen</a> des Arrays können nicht auf diese benannten Eigenschaften angewendet werden.</p>

<h3 id="Accessing_array_elements" name="Accessing_array_elements">Auf Elemente des Arrays zugreifen</h3>

<p>JavaScript-Arrays sind nullindiziert: Das erste Element eines Arrays befindet sich am Index <code>0</code>, das letzte Element befindet sich an demjenigen Index, der dem Wert der Eigenschaft {{jsxref ("Array.length", "length")}} des Arrays minus 1 entspricht. Die Verwendung einer ungültigen Indexnummer gibt <code>undefined</code> zurück.</p>

<pre class="brush: js">var arr = ['Das erste Element', 'Das zweite Element', 'Das letzte Element'];
console.log(arr[0]);              // Ausgabe: 'Das erste Element'
console.log(arr[1]);              // Ausgabe: 'Das zweite Element'
console.log(arr[arr.length - 1]); // Ausgabe: 'Das letzte Element'
</pre>

<p>Array-Elemente sind Objekteigenschaften genau so wie <code>toString</code>. Wenn man jedoch wie folgt auf ein Element eines Arrays versucht zuzugreifen, wird ein Syntaxfehler ausgegeben, da der Name der Eigenschaft ungültig ist:</p>

<pre class="brush: js">console.log(arr.0); // Syntaxfehler
</pre>

<p>Es gibt nichts Besonderes an JavaScript-Arrays und den Eigenschaften, die dies verursachen. JavaScript-Eigenschaften, die mit einer Ziffer beginnen, können nicht mit Punktnotation referenziert werden und müssen über Klammernotation aufgerufen werden. Wenn man beispielsweise ein Objekt mit einer Eigenschaft namens <code>'3d'</code> hat, kann es nur in Klammern angegeben werden, z. B.:</p>

<pre class="brush: js">var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
console.log(years.0);   // ein Syntaxfehler
console.log(years[0]);  // funktioniert
</pre>

<pre class="brush: js">renderer.3d.setTexture(model, 'character.png');     // ein Syntaxfehler
renderer['3d'].setTexture(model, 'character.png');  // works funktioniert
</pre>

<p>Beachten Sie, dass im obigen Beispiel <code>'3d'</code> in Anführungszeichen gesetzt werden musste. Es ist auch möglich, die JavaScript-Array-Indizes in Anführungszeichen zu setzen (z. B. <code>years['2']</code> statt <code>years[2]</code>), obwohl dies nicht erforderlich ist. Die 2 in <code>years[2]</code> wird von der JavaScript-Engine durch eine implizite Konvertierung mittels <code>toString</code> zwingend in eine Zeichenfolge umgewandelt. Aus diesem Grund beziehen sich <code>'2'</code> und <code>'02'</code> auf zwei unterschiedliche Elemente des <code>years</code>-Objekts und das folgende Beispiel würde <code>true</code> ergeben:</p>

<pre class="brush: js">console.log(years['2'] != years['02']);
</pre>

<p>Ebenso kann auf Objekteigenschaften, die zufällig reservierte Wörter(!) sind, nur als Stringliterale in Klammern zugegriffen werden:</p>

<pre class="brush: js">var promise = {
  'var'  : 'text',
  'array': [1, 2, 3, 4]
};

console.log(promise['var']);
</pre>

<h3 id="Relationship_between_length_and_numerical_properties" name="Relationship_between_length_and_numerical_properties">Beziehung zwischen <code>length</code> und numerischen Eigenschaften</h3>

<p>Die Eigenschaft {{jsxref("Array.length", "length")}} eines JavaScript-Arrays und numerische Eigenschaften sind miteinander verbunden. Etliche der eingebauten Array-Methoden (z. B. {{jsxref("Array.join", "join()")}}, {{jsxref("Array.slice", "slice()")}}, {{jsxref("Array.indexOf", "indexOf()")}}, etc.) berücksichtigen den Wert der {{jsxref("Array.length", "length")}} Eigenschaft eines Arrays, wenn diese aufgerufen werden. Andere Methoden (z. B. {{jsxref("Array.push", "push()")}}, {{jsxref("Array.splice", "splice()")}}, etc.) bewirken ebenfalls eine Veränderung der Eigenschaft {{jsxref("Array.length", "length")}} eines Arrays.</p>

<pre class="brush: js">var fruits = [];
fruits.push('banana', 'apple', 'peach');

console.log(fruits.length); // 3
</pre>

<p>Wird einem JavaScript-Array eine Eigenschaft zugewiesen, bei der es sich um einen gültigen Array-Index handelt und dieser Index außerhalb der aktuellen Grenzen des Arrays liegt, aktualisiert die Engine die Eigenschaft {{jsxref("Array.length", "length")}} des Arrays entsprechend:</p>

<pre class="brush: js">fruits[5] = 'mango';
console.log(fruits[5]); // 'mango'
console.log(Object.keys(fruits));  // ['0', '1', '2', '5']
console.log(fruits.length); // 6
</pre>

<p>Beim Erhöhen von {{jsxref("Array.length", "length")}}.</p>

<pre class="brush: js">fruits.length = 10;
console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
console.log(fruits.length); // 10
</pre>

<div>
<p>Beim Verringern von {{jsxref("Array.length", "length")}} werden jedoch Elemente gelöscht.</p>

<pre class="brush: js">fruits.length = 2;
console.log(Object.keys(fruits)); // ['0', '1']
console.log(fruits.length); // 2
</pre>

<p>Der Artikel zu {{jsxref("Array.length")}} geht genauer darauf ein.</p>
</div>

<h3 id="Creating_an_array_using_the_result_of_a_match" name="Creating_an_array_using_the_result_of_a_match">Erstellen eines Arrays als Ergebnis einer Übereinstimmung</h3>

<p>Das Ergebnis einer Übereinstimmung eines regulären Ausdrucks und einem String kann ein JavaScript-Array erstellen. Dieses Array verfügt über Eigenschaften und Elemente, die Informationen zur Übereinstimmung beinhalten. Solch ein Array wird von {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}} und {{jsxref("String.replace")}} zurückgegeben. Am folgenden Beispiel sollen diese Eigenschaften und Elemente erläutert werden, die Tabelle darunter enthält; weitere Informationen hierzu:</p>

<pre class="brush: js">// Übereinstimmung eines d, gefolgt von einem oder mehreren b, gefolgt von einem d
// Übereinstimmende b's und die darauf folgenden d's merken
// Groß-/Kleinschreibung ignorieren

var myRegEx = /d(b+)(d)/i;
var myArray = myRegEx.exec('cdbBdbsbz');</pre>

<p>Die Eigenschaften und Elemente werden wie folgt zurückgegeben:</p>

<table class="fullwidth-table">
 <tbody>
  <tr>
   <td class="header">Eigenschaft/Element</td>
   <td class="header">Beschreibung</td>
   <td class="header">Beispiel</td>
  </tr>
  <tr>
   <td><code>input</code></td>
   <td>
    <p>Eine schreibgeschützte Eigenschaft, die die ursprüngliche Zeichenfolge widerspiegelt, mit der der reguläre Ausdruck abgeglichen wurde.</p>
   </td>
   <td>cdbBdbsbz</td>
  </tr>
  <tr>
   <td><code>index</code></td>
   <td>Eine schreibgeschützte Eigenschaft, bei der es sich um den nullbasierten Index der Übereinstimmung in der Zeichenfolge handelt.</td>
   <td>1</td>
  </tr>
  <tr>
   <td><code>[0]</code></td>
   <td>Ein schreibgeschütztes Element, das die zuletzt übereinstimmenden Zeichen angibt.</td>
   <td>dbBd</td>
  </tr>
  <tr>
   <td><code>[1], ...[n]</code></td>
   <td>Schreibgeschützte Elemente, die die in Klammern gesetzten Unterzeichenfolgen angeben, sofern sie im regulären Ausdruck enthalten sind. Die Anzahl der möglichen geklammerten Teilzeichenfolgen ist unbegrenzt.</td>
   <td>[1]: bB<br>
    [2]: d</td>
  </tr>
 </tbody>
</table>

<h2 id="Properties" name="Properties">Eigenschaften</h2>

<dl>
 <dt>Array.length</dt>
 <dd>Die Eigenschaft <code>length</code> des <code>Array-</code>Konstruktors, deren Wert 1 ist.</dd>
 <dt>{{jsxref("Array.@@species", "get Array[@@species]")}}</dt>
 <dd>Die Konstruktorfunktion zum Erstellen abgeleiteter Objekte.</dd>
 <dt>{{jsxref("Array.prototype")}}</dt>
 <dd>Ermöglicht das Hinzufügen von Eigenschaften zu allen Array-Objekten.</dd>
</dl>

<h2 id="Methods" name="Methods">Methoden</h2>

<dl>
 <dt>{{jsxref("Array.from()")}}</dt>
 <dd>Erstellt eine neue <code>Array</code>-Instanz aus einem Array-ähnlichen oder iterierbaren Objekt.</dd>
 <dt>{{jsxref("Array.isArray()")}}</dt>
 <dd>Gibt <code>true</code> zurück, wenn eine Variable ein Array ist, andernfalls <code>false</code>.</dd>
 <dt>{{jsxref("Array.of()")}}</dt>
 <dd>Erstellt eine neue <code>Array</code>-Instanz mit einer variablen Anzahl von Argumenten, unabhängig von Anzahl oder Typ der Argumente.</dd>
</dl>

<h2 id="Array_instances" name="Array_instances"><code>Array</code> Instanzen</h2>

<p>Alle <code>Array</code>-Instanzen erben von {{jsxref("Array.prototype")}}. Das Prototypobjekt des <code>Array</code>-Konstruktors kann geändert werden, um alle <code>Array</code>-Instanzen zu beeinflussen.</p>

<h3 id="Methods_of_array_instances" name="Methods_of_array_instances">Eigenschaften</h3>

<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Eigenschaften')}}</div>

<h3 id="Methods_of_array_instances" name="Methods_of_array_instances">Methoden</h3>

<h4 id="Mutator_methods" name="Mutator_methods">Mutationsmethoden</h4>

<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutationsmethoden')}}</div>

<h4 id="Accessor_methods" name="Accessor_methods">Zugriffsmethoden</h4>

<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Zugriffsmethoden')}}</div>

<h4 id="Iteration_methods" name="Iteration_methods">Zählmethoden</h4>

<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Zählmethoden')}}</div>

<h2 id="Array_generic_methods" name="Array_generic_methods">Generische <code>Array</code>-Methoden</h2>

<div class="warning">
<p><strong>Generische Array Methoden sind nicht standardisiert, veraltet und werden in naher Zukunft entfernt. </strong></p>
</div>

<p>Manchmal möchte man Array-Methoden auf Strings oder andere Array-ähnliche Objekte anwenden (z. B. auf {{jsxref("Functions/arguments", "Argumente", "", 1)}} von Funktionen). Auf diese Weise behandelt man eine Zeichenfolge wie ein Array von Zeichen (oder ein nicht-Array wie ein Array). Um beispielsweise zu prüfen, ob jedes Zeichen in der Variablen <code><em>str</em></code> ein Buchstabe ist, würde man Folgendes schreiben:</p>

<pre class="brush: js">function isLetter(character) {
  return character &gt;= 'a' &amp;&amp; character &lt;= 'z';
}

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

<p>Diese Schreibweise wurde in JavaScript 1.6 von einer kürzeren abgelöst:</p>

<pre class="brush: js">if (Array.every(str, isLetter)) {
  console.log("The string '" + str + "' contains only letters!");
}
</pre>

<p>{{jsxref("Global_Objects/String", "Generische Methoden", "#Generische_String-Methoden", 1)}} gibt es ebenfalls für {{jsxref("Global_Objects/String", "Strings")}}.</p>

<p>Diese sind <strong>nicht</strong> Teil der ECMAScript-Standards und werden von nicht-Gecko-Browsern nicht unterstützt. Als Standardvariante können Sie Ihr Objekt mit {{jsxref("Array.from()")}} in ein richtiges Array konvertieren. Diese Methode wird in alten Browsern möglicherweise nicht unterstützt:</p>

<pre class="brush: js">if (Array.from(str).every(isLetter)) {
  console.log("The string '" + str + "' contains only letters!");
}
</pre>

<h2 id="Examples" name="Examples">Beispiele</h2>

<h3 id="Example_Creating_an_array" name="Example:_Creating_an_array">Erstellen eines Arrays</h3>

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

<pre class="brush: js">var msgArray = [];
msgArray[0] = 'Hello';
msgArray[99] = 'world';

if (msgArray.length === 100) {
  console.log('Die Länge ist 100.');
}
</pre>

<h3 id="Example_Creating_a_two-dimensional_array" name="Example:_Creating_a_two-dimensional_array">Erstellen eines zweidimensionalen Arrays</h3>

<p>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.</p>

<pre class="brush: js">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'));
</pre>

<p>Das ist die Ausgabe:</p>

<pre class="eval">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
</pre>

<h3 id="Einsatz_eines_Arrays_um_Werte_tabellarisch_auszugeben">Einsatz eines Arrays, um Werte tabellarisch auszugeben</h3>

<pre class="brush: js">values = [];
for (var x = 0; x &lt; 10; x++){
 values.push([
  2 ** x,
  2 * x ** 2
 ])
};
console.table(values)</pre>

<p>Das Resultat ist:</p>

<pre class="eval">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</pre>

<p>(Die erste Spalte ist der Index)</p>

<h2 id="Specifications" name="Specifications">Spezifikationen</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Spezifikation</th>
   <th scope="col">Status</th>
   <th scope="col">Kommentar</th>
  </tr>
  <tr>
   <td>{{SpecName('ES1')}}</td>
   <td>{{Spec2('ES1')}}</td>
   <td>Initiale Definition.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-15.4', 'Array')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td>Neue Methoden hinzugefügt: {{jsxref("Array.isArray")}}, {{jsxref("Array.prototype.indexOf", "indexOf")}}, {{jsxref("Array.prototype.lastIndexOf", "lastIndexOf")}}, {{jsxref("Array.prototype.every", "every")}}, {{jsxref("Array.prototype.some", "some")}}, {{jsxref("Array.prototype.forEach", "forEach")}}, {{jsxref("Array.prototype.map", "map")}}, {{jsxref("Array.prototype.filter", "filter")}}, {{jsxref("Array.prototype.reduce", "reduce")}}, {{jsxref("Array.prototype.reduceRight", "reduceRight")}}</td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-array-objects', 'Array')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td>Neue Methoden hinzugefügt: {{jsxref("Array.from")}}, {{jsxref("Array.of")}}, {{jsxref("Array.prototype.find", "find")}}, {{jsxref("Array.prototype.findIndex", "findIndex")}}, {{jsxref("Array.prototype.fill", "fill")}}, {{jsxref("Array.prototype.copyWithin", "copyWithin")}}</td>
  </tr>
  <tr>
   <td>{{SpecName('ES7', '#sec-array-objects', 'Array')}}</td>
   <td>{{Spec2('ES7')}}</td>
   <td>Neue Methode hinzugefügt: {{jsxref("Array.prototype.includes()")}}</td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-array-objects', 'Array')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td></td>
  </tr>
 </tbody>
</table>

<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2>



<p>{{Compat("javascript.builtins.Array")}}</p>

<h2 id="See_also" name="See_also">Siehe auch</h2>

<ul>
 <li><a href="/de/docs/Web/JavaScript/Guide/Mit_Objekten_arbeiten#Indexing_object_properties">JavaScript Guide: “Indexing object properties”</a></li>
 <li><a href="/de/docs/Web/JavaScript/Guide/Predefined_Core_Objects#Array_Object">JavaScript Guide: “Predefined Core Objects: <code>Array</code> Object”</a></li>
 <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Array_comprehensions">Array comprehensions</a></li>
 <li><a href="https://github.com/plusdude/array-generics">Polyfill für JavaScript 1.8.5 generische Arrays und ECMAScript 5 Array Extras</a></li>
 <li><a href="/de/docs/JavaScript_typed_arrays">Typisierte Arrays</a></li>
</ul>