initial commit

1 files changed, 448 insertions, 0 deletions

diff --git a/files/de/web/javascript/guide/indexed_collections/index.html b/files/de/web/javascript/guide/indexed_collections/index.html
new file mode 100644
index 0000000000..fa47c0841b
--- /dev/null
+++ b/files/de/web/javascript/guide/indexed_collections/index.html
@@ -0,0 +1,448 @@
+---
+title: Indexed collections
+slug: Web/JavaScript/Guide/Indexed_collections
+tags:
+  - Guide
+  - Handbuch
+  - JavaScript
+  - Method
+  - Méthode
+  - 'l10n:priority'
+translation_of: Web/JavaScript/Guide/Indexed_collections
+---
+<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Regular_Expressions", "Web/JavaScript/Guide/Keyed_Collections")}}</div>
+
+<p class="summary">Dieses Kapitel beschreibt Datensammlungen, die nach einem Indexwert sortiert sind. Diese beinhalten Arrays und Array-ähnliche Konstrukte, wie {{jsxref("Array")}} Objekte {{jsxref("TypedArray")}} Objekte.</p>
+
+<h2 id="Array_Objekt"><code>Array</code> Objekt</h2>
+
+<p>Ein <em>Array</em> ist ein sortiertes Set an Werten, die mit einem Namen und einem Index referenziert werden. Zum Beispiel könnte ein Array mit dem Namen <code>emp</code> Mitarbeiternamen enthalten, die über ihre Mitarbeiternummer indexiert sind. <code>emp[1]</code> würde somit Mitarbeiter Eins sein, <code>emp[2]</code> ist Mitarbeiter Zwei, und so weiter.</p>
+
+<p>JavaScript hat keinen expliziten Array-Datentyp, aber es ist möglich, das vordefinierte <code>Array</code> Objekt und dessen Methoden zu verwenden, um mit Arrays zu arbeiten. Das <code>Array</code> Objekt verfügt über Methoden, um Arrays auf unterschiedliche Weisen zu manipulieren. Es hat ein Property um die Arraylänge zu bestimmen, und andere Properties für die Verwendung von Regular Expressions.</p>
+
+<h3 id="Ein_Array_erstellen">Ein Array erstellen</h3>
+
+<p>Die folgenden Statements erstellen äquivalente Arrays:</p>
+
+<pre class="brush: js">var arr = new Array(element0, element1, ..., elementN);
+var arr = Array(element0, element1, ..., elementN);
+var arr = [element0, element1, ..., elementN];
+</pre>
+
+<p><code>element0, element1, ..., elementN</code> ist eine Liste von Werten für die Elemente im Array. Das Array wird mit den Werten als Elemente initialisiert. Das <code>length</code> Property des Arrays entspricht dann der Anzahl Argumente.</p>
+
+<p>Die Bracket-Syntax wird als "Array-Literal" oder "Array-Initialisierer" bezeichnet. Es ist eine kürzere Form der Array-Erstellung und wird allgemein bevorzugt. Siehe <a href="/en-US/docs/Web/JavaScript/Guide/Grammar_and_types#Array_literals">Array literals</a> für weitere Details.</p>
+
+<p>Um ein leeres Array mit einer Länge von mehr als Null zu erstellen, kann eine der folgenden Statements verwendet werden:</p>
+
+<pre class="brush: js">var arr = new Array(arrayLength);
+var arr = Array(arrayLength);
+
+// Folgendes hat den selben Effekt.
+var arr = [];
+arr.length = arrayLength;
+</pre>
+
+<div class="note">
+<p><strong>Bemerkung :</strong> im obigen Code, <code>arrayLength</code> muss ein <code>Number</code> Objekt sein, ansonsten wird ein Array mit einem Element (dem übergebenen Wert) erstellt. Ein Aufruf von <code>arr.length</code> wird <code>arrayLength</code> zurückgeben, aber das Array besteht aus leeren (<code>undefined</code>) Elementen. Eine {{jsxref("Statements/for...in","for...in")}} Schleife wird keine der Elemente aus dem Array zurückgeben.</p>
+</div>
+
+<p>Neben der Zuweisung an eine neue Variable, wie im Beispiel oben gezeigt, können Arrays auch als Property eines neuen oder existierenden Objekts zugewiesen werden:</p>
+
+<pre class="brush: js">var obj = {};
+// Weist das Array einem Property des bestehenden Objekts 'obj'
+// zu.
+obj.prop = [element0, element1, ..., elementN];
+
+// Weist das Array einem Property auf dem neuen Objekt 'obj'
+// zu.
+var obj = {prop: [element0, element1, ...., elementN]};
+</pre>
+
+<p>Wenn ein Array mit einem einzelnen <code>Number</code> Objekt erstellt werden soll, muss die Bracket-Syntax verwendet werden. Wenn ein einzelnes <code>Number</code> Objekt an den/der Array() Konstruktor oder Funktion übergeben wird, wird es als <code>arrayLength</code> und nicht als einzelnes Element interpretiert.</p>
+
+<pre class="brush: js">var arr = [42];      // Erstellt ein Array mit genau einem
+                     // Element: der Nummer 42.
+
+var arr = Array(42); // Erstellt ein Array ohne Elemente und
+                     // arr.length wird als 42 gesetzt; dies
+                     // ist äquivalent zu:
+var arr = [];
+arr.length = 42;
+</pre>
+
+<p>Wenn <code>Array(N)</code> aufgerufen wird und <code>N</code> keine Ganzzahl ist, wird ein <code>RangeError</code> geworfen. Das folgende Beispiel illustriert dieses Verhalten:</p>
+
+<pre class="brush: js">var arr = Array(9.3);  // RangeError: Invalid array length
+                       // "Ungültige Array-Länge"</pre>
+
+<p>Wenn im Code Arrays mit einzelnen Elements eines willkürlichen Datentyp verlangt sind, ist es sicherer, Array-Literals zu verwenden, oder zuerst ein leeres Array zu erstellen und dann das einzelne Element hinzuzufügen.</p>
+
+<h3 id="Ein_Array_abfüllen">Ein Array abfüllen</h3>
+
+<p>Ein Array kann abgefüllt werden, indem dessen Elemente mit Werten abgefüllt werden:</p>
+
+<pre class="brush: js">var emp = [];
+emp[0] = 'Casey Jones';
+emp[1] = 'Phil Lesh';
+emp[2] = 'August West';
+</pre>
+
+<div class="note">
+<p><strong>Bemerkung :</strong> Wenn ein Wert dem Array-Operator übergeben wird, der kein Integer ist, wie im obigen Code, wird ein Property auf dem Array-Objekt erstellt, statt als Array-Element.</p>
+
+<p>Der Array-Operator ist die Rechteckige Klammer nach der Array-Variable.</p>
+</div>
+
+<pre class="brush: js">var arr = [];
+arr[3.4] = 'Oranges';
+console.log(arr.length);                // 0
+console.log(arr.hasOwnProperty(3.4));   // true
+</pre>
+
+<p>Arrays können auch bei der Erstellung abgefüllt werden:</p>
+
+<pre class="brush: js">var myArray = new Array('Hello', myVar, 3.14159);
+var myArray = ['Mango', 'Apple', 'Orange'];
+</pre>
+
+<h3 id="Array-Elemente_referenzieren">Array-Elemente referenzieren</h3>
+
+<p>Ein Element in einem Array kann mit dessen Ordinalzahl (Index) referenziert werden. Beispielweise wird der folgende Array erstellt:</p>
+
+<pre class="brush: js">var myArray = ['Earth', 'Wind', 'Fire'];
+</pre>
+
+<p>Das erste Element kann mit <code>myArray[0]</code>, und das zweite Element des Arrays mit <code>myArray[1]</code> referenziert werden. Der Index der Elemente beginnt mit Null.</p>
+
+<div class="note">
+<p><strong>Bemerkung :</strong> Der Array-Operator (Rechteckige Klammer) wird auch für den Zugriff auf die Properties des Arrays (Arrays sind in JavaScript auch Objekte) verwendet. Beispielsweise:</p>
+</div>
+
+<pre class="brush: js">var arr = ['one', 'two', 'three'];
+arr[2];                            // three
+arr['length'];                     // 3
+</pre>
+
+<h3 id="Das_length_Property_verstehen">Das length Property verstehen</h3>
+
+<p>Auf dem Implementierungslevel, Arrays in JavaScript legen ihre Elemente als normale Properties eines Objekts (dem Array selbst) mit dessen Index als Property-Name ab. Das <code>length</code> Property ist speziell; Es gibt immer den Index des letzen Elements plus Eins (im folgenden Beispiel hat Dusty den Index 30, also gibt <code>cats.length</code> 30 + 1 zurück) zurück. Array-Indexe starten in JavaScript immer mit 0 und nicht mit 1. Dies bedeutet, dass das <code>length</code> Property immer um Eins grösser ist, als der höchste Index im Array:</p>
+
+<pre class="brush: js">var cats = [];
+cats[30] = ['Dusty'];
+console.log(cats.length); // 31
+</pre>
+
+<p>Das <code>length</code> Property kann auch beschrieben werden. Wird ein Wert zugewiesen, der kleiner ist, als die Anzahl Elemente im Array, wird das Array auf die angegebene Grösse geschrumpft; das Array wird geleert, wenn 0 zugewiesen wird:</p>
+
+<pre class="brush: js">var cats = ['Dusty', 'Misty', 'Twiggy'];
+console.log(cats.length); // 3
+
+cats.length = 2;
+console.log(cats); // Loggt "Dusty, Misty" - Twiggy wurde
+                   // entfernt.
+
+cats.length = 0;
+console.log(cats); // Loggt nichts; Das 'cats' Array ist leer.
+
+cats.length = 3;
+console.log(cats); // Loggt [undefined, undefined, undefined].
+</pre>
+
+<h3 id="Iteration_über_Arrays">Iteration über Arrays</h3>
+
+<p>Eine gebräuchliche Operation ist die Iteration über die Werte eines Arrays, um jedes Element auf eine Weise zu verarbeiten. Die einfachste Variate ist:</p>
+
+<pre class="brush: js">var colors = ['red', 'green', 'blue'];
+for (var i = 0; i &lt; colors.length; i++) {
+  console.log(colors[i]);
+}
+</pre>
+
+<p>Wenn es ausgeschlossen ist, dass eines der Elemente im Array in einem Boolean-Kontext als <code>false</code> evaluiert wird — beispielsweise, wenn es nur aus <a href="/en-US/docs/DOM" title="en-US/docs/DOM">DOM</a> Knoten besteht — kann ein effizienterer Ausdruck verwendet werden:</p>
+
+<pre class="brush: js">var divs = document.getElementsByTagName('div');
+for (var i = 0, div; div = divs[i]; i++) {
+  /* Verarbeite das div auf irgendeine Weise. */
+}
+</pre>
+
+<p>Dies vermeidet den Overhead bei der Überprüfung der Array-Länge und  weist der <code>div</code> Variable den aktuellen Wert des Schleifendurchlaufs sofort zu.</p>
+
+<p>Die {{jsxref("Array.forEach", "forEach()")}} Methode erlaubt eine andere Variate zur Iteration über ein Array:</p>
+
+<pre class="brush: js">var colors = ['red', 'green', 'blue'];
+colors.forEach(function(color) {
+  console.log(color);
+});
+</pre>
+
+<p>Die Funktion, die <code>forEach</code> übergeben wird, wird für jedes Element im Array ausgeführt, wobei das Element als Argument der Funktion übergeben wird. Elemente ohne Wert (<code>undefined</code>) werden von <code>forEach</code> nicht iteriert.</p>
+
+<p>Elemente ohne Wert werden von <code>forEach</code> nur übersprungen, wenn sie nicht manuell zugewiesen wurden:</p>
+
+<pre class="brush: js">var array = ['first', 'second', , 'fourth'];
+
+// Gibt ['first', 'second', 'fourth'] zurück.
+array.forEach(function(element) {
+  console.log(element);
+})
+
+if (array[2] === undefined) { // true
+  console.log('array[2] is undefined');
+}
+
+var array = ['first', 'second', undefined, 'fourth'];
+
+// Gibt ['first', 'second', undefined, 'fourth'] zurück.
+array.forEach(function(element) {
+  console.log(element);
+})</pre>
+
+<p>Weil JavaScript Elemente als normale Objekt-Properties abgelegt werden, ist es nicht ratsam Arrays mit {{jsxref("Statements/for...in","for...in")}} zu iterieren, weil normale Elemente plus alle aufzählbaren (enumerable) Properties aufgelistet werden.</p>
+
+<h3 id="Array-Methoden">Array-Methoden</h3>
+
+<p>Das {{jsxref("Array")}} Objekt verfügt über folgende Methoden:</p>
+
+<p>{{jsxref("Array.concat", "concat()")}} hängt zwei Arrays aneinander und gibt das kombinierte Array zurück.</p>
+
+<pre class="brush: js">var myArray = new Array('1', '2', '3');
+myArray = myArray.concat('a', 'b', 'c');
+// myArray ist nun ["1", "2", "3", "a", "b", "c"].
+</pre>
+
+<p>{{jsxref("Array.join", "join(deliminator = ',')")}} kombiniert alle Elemente eines Arrays in einen String mit einem Delimiter.</p>
+
+<pre class="brush: js">var myArray = new Array('Earth', 'Wind', 'Fire');
+var list = myArray.join(' - '); // list ist
+                                // "Earth - Wind - Fire".
+</pre>
+
+<p>{{jsxref("Array.push", "push()")}} fügt eines oder mehrere Elemente an ein Array und gibt den Wert des neuen <code>length</code> Property zurück.</p>
+
+<pre class="brush: js">var myArray = new Array('1', '2');
+myArray.push('3'); // myArray ist nun ["1", "2", "3"].
+</pre>
+
+<p>{{jsxref("Array.pop", "pop()")}} entfernt das letzte Element des Arrays und gibt es zurück.</p>
+
+<pre class="brush: js">var myArray = new Array('1', '2', '3');
+var last = myArray.pop();
+// myArray ist nun ["1", "2"], last = "3"
+</pre>
+
+<p>{{jsxref("Array.shift", "shift()")}} entfernt das erste Element des Arrays und gibt es zurück.</p>
+
+<pre class="brush: js">var myArray = new Array('1', '2', '3');
+var first = myArray.shift();
+// myArray ist nun ["2", "3"], first = "1"
+</pre>
+
+<p>{{jsxref("Array.unshift", "unshift()")}} fügt eines oder mehrere Elemente an den Anfang des Arrays und gibt den Wert des neuen <code>length</code> Property zurück.</p>
+
+<pre class="brush: js">var myArray = new Array('1', '2', '3');
+myArray.unshift('4', '5');
+// myArray wird ["4", "5", "1", "2", "3"].</pre>
+
+<p>{{jsxref("Array.slice", "slice(start_index, upto_index)")}} extrahiert einen Ausschnitt des Arrays und gibt ein neues Array zurück.</p>
+
+<pre class="brush: js">var myArray = new Array('a', 'b', 'c', 'd', 'e');
+myArray = myArray.slice(1, 4); // Beginnt bei Index 1 und
+                               // extrahiert alle Elemente bis
+                               // Index 3 und gibt somit
+                               // [ "b", "c", "d"] zurück.
+</pre>
+
+<p>{{jsxref("Array.splice", "splice(index, count_to_remove, addElement1, addElement2, ...)")}} entfernt einen Teil des Arrays und ersetzt sie (optional). Der rückgegebene Wert entspricht den entfernten Elementen.</p>
+
+<pre class="brush: js">var myArray = new Array('1', '2', '3', '4', '5');
+myArray.splice(1, 3, 'a', 'b', 'c', 'd');
+// myArray ist nun ["1", "a", "b", "c", "d", "5"].
+// Dieser Code startet mit Index 1 (wo '2' war), entfernt dort
+// 3 Elemente, und fügt die Werte 'a' bis '5' ein.
+</pre>
+
+<p>{{jsxref("Array.reverse", "reverse()")}} kehrt die Reihenfolge der Array-Elemente um; das erste Element ist neu das letzte und das letzte Element ist nun das erste.</p>
+
+<pre class="brush: js">var myArray = new Array('1', '2', '3');
+myArray.reverse();
+// Kehrt die Reihenfolge der Array-Elemente um.
+// myArray = ["3", "2", "1"]
+</pre>
+
+<p>{{jsxref("Array.sort", "sort()")}} sortiert die Elemente im Array.</p>
+
+<pre class="brush: js">var myArray = new Array('Earth', 'Wind', 'Fire');
+myArray.sort();
+// Sortiert das Array.
+// myArray = ["Earth", "Fire", "Wind"]
+</pre>
+
+<p><code>sort()</code> kann auch eine Callback-Funktion verwenden, um zu bestimmen, wie die Elemente miteinander verglichen werden sollen. Die Funktion vergleicht zwei Werte und gibt einen von drei Werten zurück:</p>
+
+<p>Beispielsweise wird der folgende Code das Array nach dem letzten Buchstaben des Strings sortieren:</p>
+
+<pre class="brush: js">var sortFn = function(a, b) {
+  if (a[a.length - 1] &lt; b[b.length - 1]) return -1;
+  if (a[a.length - 1] &gt; b[b.length - 1]) return 1;
+  if (a[a.length - 1] == b[b.length - 1]) return 0;
+}
+myArray.sort(sortFn);
+// Sortiert das Array nach dem letzten Buchstaben.
+// myArray = ["Wind","Fire","Earth"]</pre>
+
+<ul>
+ <li>Wenn <code>a</code> kleiner ist als <code>b</code>, -1 (oder eine andere negative Zahl) wird zurückgegeben</li>
+ <li>Wenn <code>a</code> ist grösser als <code>b</code>, 1 (oder eine andere positive Zahl) wird zurückgegeben</li>
+ <li>Wenn <code>a</code> und <code>b</code> äquivalent sind, wird 0 zurückgegeben.</li>
+</ul>
+
+<p>{{jsxref("Array.indexOf", "indexOf(searchElement[, fromIndex])")}} durchsucht das Array nach <code>searchElement</code> und gibt den Index des ersten Treffers zurück.</p>
+
+<pre class="brush: js">var a = ['a', 'b', 'a', 'b', 'a'];
+console.log(a.indexOf('b')); // Loggt 1.
+// Nochmals, die Suche beginnt ab dem Element mit dem Index 2.
+console.log(a.indexOf('b', 2)); // Loggt 3.
+console.log(a.indexOf('z')); // Loggt -1, weil 'z' nicht
+                             // gefunden wurde.
+</pre>
+
+<p>{{jsxref("Array.lastIndexOf", "lastIndexOf(searchElement[, fromIndex])")}} funktioniert wie <code>indexOf</code>, aber startet die Suche am Ende des Arrays.</p>
+
+<pre class="brush: js">var a = ['a', 'b', 'c', 'd', 'a', 'b'];
+console.log(a.lastIndexOf('b')); // Loggt 5.
+// Startet die Suche ab dem Element mit dem Index 4.
+console.log(a.lastIndexOf('b', 4)); // Loggt 1.
+console.log(a.lastIndexOf('z')); // Loggt -1.
+</pre>
+
+<p>{{jsxref("Array.forEach", "forEach(callback[, thisObject])")}} führt <code>callback</code> für jedes Element aus.</p>
+
+<pre class="brush: js">var a = ['a', 'b', 'c'];
+a.forEach(function(element) { console.log(element); });
+// Loggt jedes Element.
+</pre>
+
+<p>{{jsxref("Array.map", "map(callback[, thisObject])")}} gibt ein neues Array zurück, aus dem Rückgabewert der <code>callback</code> Funktion.</p>
+
+<pre class="brush: js">var a1 = ['a', 'b', 'c'];
+var a2 = a1.map(function(item) { return item.toUpperCase(); });
+console.log(a2); // Loggt ['A', 'B', 'C'].
+</pre>
+
+<p>{{jsxref("Array.filter", "filter(callback[, thisObject])")}} gibt ein Array zurück, das aus allen Elementen besteht, bei denen die <code>callback</code> Funtion <code>true</code> zurückgibt.</p>
+
+<pre class="brush: js">var a1 = ['a', 10, 'b', 20, 'c', 30];
+var a2 = a1.filter(function(item) { return typeof item === 'number'; });
+console.log(a2); // Loggt [10, 20, 30].
+</pre>
+
+<p>{{jsxref("Array.every", "every(callback[, thisObject])")}} gibt <code>true</code> zurück, wenn die <code>callback</code> Funktion für jedes Element auch <code>true</code> zurückgibt.</p>
+
+<pre class="brush: js">function isNumber(value) {
+  return typeof value === 'number';
+}
+var a1 = [1, 2, 3];
+console.log(a1.every(isNumber)); // Loggt true.
+var a2 = [1, '2', 3];
+console.log(a2.every(isNumber)); // Loggt false.
+</pre>
+
+<p>{{jsxref("Array.some", "some(callback[, thisObject])")}} gibt <code>true</code> zurück, wenn die <code>callback</code> Funktion für alle Elemente mindestens einmal <code>true</code> zurückgibt.</p>
+
+<pre class="brush: js">function isNumber(value) {
+  return typeof value === 'number';
+}
+var a1 = [1, 2, 3];
+console.log(a1.some(isNumber)); // Loggt true.
+var a2 = [1, '2', 3];
+console.log(a2.some(isNumber)); // Loggt true.
+var a3 = ['1', '2', '3'];
+console.log(a3.some(isNumber)); // Loggt false.
+</pre>
+
+<p>Die obige Methoden, die eine <code>callback</code> Funktion als Argument verlangen sind als <em>Iterative Methoden</em> bekannt, weil sie über das ganze Array auf irgendeine Weise iterieren. Jede der Methoden nimmt ein optionales zweites Argument <code>thisObject</code>. Wenn <code>thisObject</code> übergeben wird, wird es im Kontext der <code>callback</code> Funktion als <code>this</code> behandelt. Falls es nicht übergeben wird, wie es auch der Fall ist, wenn eine Funktion ausserhalb eines expliziten Objektkontext aufgerufen wird, referenziert this das globale Objekt ({{domxref("window")}}).</p>
+
+<p>Die <code>callback</code> Funktion wird jeweils mit drei Argumenten aufgerufen. Das erste ist der Wert des aktuellen Elements in der Iteration, das zweite ist der Index des Elements und das dritte ist eine Referenz auf das Array selbst. JavaScript Funktionen ignorieren Parameter, die in der Liste nicht benannt werden, es ist somit sicher, eine Funktion als <code>callback</code> zu definieren, die nur ein einzelnes Argument nimmt, zum Beispiel <code>alert</code>.</p>
+
+<p> </p>
+
+<p>{{jsxref("Array.reduce", "reduce(callback[, initialValue])")}} wendet <code>callback(firstValue, secondValue)</code> an, um die Liste auf einen einzelnen Wert zu reduzieren.</p>
+
+<pre class="brush: js">var a = [10, 20, 30];
+var total = a.reduce(function(first, second) { return first + second; }, 0);
+console.log(total) // Loggt 60.
+</pre>
+
+<p>{{jsxref("Array.reduceRight", "reduceRight(callback[, initialValue])")}} funktioniert wie <code>reduce()</code>, aber startet am Ende des Arrays.</p>
+
+<p><code>reduce</code> und <code>reduceRight</code> sind die unauffälligsten iterativen Array-Methoden. Sie sollten dazu verwendet werden, rekursiv jeweils zwei Werte miteinander zu kombinieren, bis nur noch ein einzelner Wert verbleibt.</p>
+
+<h3 id="Mehrdimensionale_Arrays">Mehrdimensionale Arrays</h3>
+
+<p>Arrays können verschachtelt sein. Das bedeutet, dass ein Array ein anderes Array als Element beinhalten kann. Mit dieser EIgenschaft von JavaScript können mehrdimensionale Arrays erstellt werden. Der folgende Code erstellt ein zwei-dimensionales Array:</p>
+
+<pre class="brush: js">var a = new Array(4);
+for (i = 0; i &lt; 4; i++) {
+  a[i] = new Array(4);
+  for (j = 0; j &lt; 4; j++) {
+    a[i][j] = '[' + i + ', ' + j + ']';
+  }
+}
+</pre>
+
+<p>Dieses Beispiel erstellt ein Array mit den folgenden Zeilen:</p>
+
+<pre>Zeile 0: [0, 0] [0, 1] [0, 2] [0, 3]
+Zeile 1: [1, 0] [1, 1] [1, 2] [1, 3]
+Zeile 2: [2, 0] [2, 1] [2, 2] [2, 3]
+Zeile 3: [3, 0] [3, 1] [3, 2] [3, 3]
+</pre>
+
+<h3 id="Arrays_und_Regular_Expressions">Arrays und Regular Expressions</h3>
+
+<p>Wenn ein Array das Resultat einer Regular Expression auf einem String ist, wird das Array Properties und Elemente zuückgeben, die Informationen zum Match liefern. Der Rückgabewert der {{jsxref("Global_Objects/RegExp/exec","RegExp.exec()")}}, {{jsxref("Global_Objects/String/match","String.match()")}}, und {{jsxref("Global_Objects/String/split","String.split()")}} Methode ist ein Array. Für weitere Informationen für die Verwendung von Arrays mit Regular Expressions, siehe <a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a>.</p>
+
+<h3 id="Mit_Array-ähnlichen_Objekten_arbeiten">Mit Array-ähnlichen Objekten arbeiten</h3>
+
+<p>Manche JavaScript Objekte, wie {{domxref("NodeList")}}, welche von {{domxref("document.getElementsByTagName()")}} zurückgegeben oder als {{jsxref("Functions/arguments","arguments")}} in einem Funktionskörper referenziert wird, verhalten sich wie Arrays, aber teilen nicht alle deren Methoden. Das <code>arguments</code> Objekt stellt ein {{jsxref("Global_Objects/Function/length","length")}} Attribut zur Verfügung, implementiert aber beispielsweise nicht die {{jsxref("Array.forEach", "forEach()")}} Methode.</p>
+
+<p>Array Prototyp-Methoden können auf einem Array-ähnlichen Objekt aufgerufen werden, siehe folgendes Beispiel:</p>
+
+<pre class="brush: js">function printArguments() {
+  Array.prototype.forEach.call(arguments, function(item) {
+    console.log(item);
+  });
+}
+</pre>
+
+<p>Array Prototyp-Methoden können auch für Strings verwendet werden, weil diese einen sequenziellen Zugriff auf deren Zeichen erlauben, ähnlich wie Arrays:</p>
+
+<pre class="brush: js">Array.prototype.forEach.call('a string', function(chr) {
+  console.log(chr);
+});</pre>
+
+<h2 id="Typisierte_Arrays">Typisierte Arrays</h2>
+
+<p><a href="/en-US/docs/Web/JavaScript/Typed_arrays">JavaScript typisierte Arrays</a> sind Array-ähnliche Objekte und stellen einen Mechanismus für den Zugriff auf Raw-Binärdaten zur Verfügung. Wie bereits erklärt, passen {{jsxref("Array")}} Objekte ihre Grösse dynamisch an und können beliebige Werte enthalten. JavaScript Engines führen Optimierungen durch, damit diese Arrays schneller sind. Je stärker Web-Applikationen werden mit Features wie Audio und Video Manipulation, Zugriff auf Raw Daten mit <a href="/en-US/docs/WebSockets">WebSockets</a> und so weiter, ist es hilfreich, wenn JavaScript Code einfach und schnell Raw Binärdaten in typisierten Arrays manipulieren kann.</p>
+
+<h3 id="Buffers_und_Views_Typisierte_Array_Architektur">Buffers und Views: Typisierte Array Architektur</h3>
+
+<p>Um maximale Flexibilität und Effizienz zu erreichen, werden typisierte Arrays in JavaScript auf <strong>Buffers</strong> und V<strong>iews</strong> aufgeteilt. Ein Buffer (implementiert durch das {{jsxref("ArrayBuffer")}} Objekt) ist ein Objekt, welches einen Block Daten repräsentiert; es hat kein Format und keine Mechanismen für den Zugriff auf Inhalte. Um auf den Speicher in einem Buffer zuzugreifen, wird eine View benötigt. Eine View stellt einen Kontext — einen Datentyp, Start-Offset und eine Anzahl Elemente — zur Verfügung, welcher die Daten in einen typisierten Array verwandelt.</p>
+
+<p><img alt="Typed arrays in an ArrayBuffer" src="https://mdn.mozillademos.org/files/8629/typed_arrays.png" style="height: 278px; width: 666px;"></p>
+
+<h3 id="ArrayBuffer">ArrayBuffer</h3>
+
+<p>Der {{jsxref("ArrayBuffer")}} ist ein Datentyp, welcher für die Darstellung von generischen Binär-Daten-Buffer mit einer fixen Grösse. Der Inhalt eines <code>ArrayBuffer</code> kann nicht direkt manipuliert werden; stattdessen kann eine typisierte Array-View oder eine {{jsxref("DataView")}} erstellt werden, welches den Buffer in einem spezifischen Format darstellt, welche dann für das Lesen und Schreiben der Inhalte auf dem Buffer verwendet werden kann.</p>
+
+<h3 id="Typisierte_Array-Views">Typisierte Array-Views</h3>
+
+<p>Typisierte Array-Views haben selbstbeschreibende Namen und stellen Views für alle geläufigen numerischen Typen, wie <code>Int8</code>, <code>Uint32</code>, <code>Float64</code> und so weiter, zur Verfügung. Es gibt ein spezielles typisiertes Array: <code>Uint8ClampedArray</code>. Es klemmt (clamps) zwischen 0 und 255. Dies ist hilfreich für <a href="/en-US/docs/Web/API/ImageData">Canvas Datenverarbeitung</a>, zum Beispiel.</p>
+
+<p>{{page("/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray", "TypedArray_objects")}}</p>
+
+<p>Für weitere Informationen, siehe <a href="/en-US/docs/Web/JavaScript/Typed_arrays">JavaScript Typisierte Arrays</a> und die Referenzdokumentation für die unterschiedlichen {{jsxref("TypedArray")}} Objekte.</p>
+
+<p>{{PreviousNext("Web/JavaScript/Guide/Regular_Expressions", "Web/JavaScript/Guide/Keyed_Collections")}}</p>