initial commit

4 files changed, 545 insertions, 0 deletions

diff --git a/files/de/web/javascript/reference/functions/arguments/@@iterator/index.html b/files/de/web/javascript/reference/functions/arguments/@@iterator/index.html
new file mode 100644
index 0000000000..5625ee01df
--- /dev/null
+++ b/files/de/web/javascript/reference/functions/arguments/@@iterator/index.html
@@ -0,0 +1,78 @@
+---
+title: 'arguments[@@iterator]()'
+slug: Web/JavaScript/Reference/Functions/arguments/@@iterator
+tags:
+  - Deprecated
+  - Functions
+  - JavaScript
+  - Property
+  - arguments
+translation_of: Web/JavaScript/Reference/Functions/arguments/@@iterator
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p>Der Initialwert der <code><strong>@@iterator</strong></code> Eigenschaft ist das selbe Funktionsobjekt wie der Initialwert der {{jsxref("Array.prototype.values")}} Eigenschaft.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><var>arguments</var>[Symbol.iterator]()</pre>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Iterieren_mit_einer_for...of_Schleife">Iterieren mit einer <code>for...of</code> Schleife</h3>
+
+<pre class="brush: js">function f() {
+  // der Browser muss for..of Schleifen und
+  // let-Variablen in for Schleifen unterstützen
+  for (let letter of arguments) {
+    console.log(letter);
+  }
+}
+f('w', 'y', 'k', 'o', 'p');
+</pre>
+
+<h2 id="Spezifikationen">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('ES6', '#sec-createunmappedargumentsobject', ' CreateUnmappedArgumentsObject')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initiale Definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-createmappedargumentsobject', ' CreateMappedArgumentsObject')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initiale Definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-createunmappedargumentsobject', 'CreateUnmappedArgumentsObject')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-createmappedargumentsobject', 'CreateMappedArgumentsObject')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.functions.arguments.@@iterator")}}</p>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.values()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/functions/arguments/callee/index.html b/files/de/web/javascript/reference/functions/arguments/callee/index.html
new file mode 100644
index 0000000000..704813b7a6
--- /dev/null
+++ b/files/de/web/javascript/reference/functions/arguments/callee/index.html
@@ -0,0 +1,157 @@
+---
+title: arguments.callee
+slug: Web/JavaScript/Reference/Functions/arguments/callee
+tags:
+  - Deprecated
+  - Functions
+  - JavaScript
+  - Property
+  - arguments
+translation_of: Web/JavaScript/Reference/Functions/arguments/callee
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p>Die <strong><code>arguments.callee</code></strong>-Eigenschaft enthält die Referenz der aktuell ausgeführten Funktion.</p>
+
+<h2 id="Description" name="Description">Beschreibung</h2>
+
+<p><code>callee</code> ist eine Eigenschaft des <code>arguments</code>-Objektes. Sie kann eingesetzt werden, um aus dem Körper einer Funktion auf die aktuell ausgeführte Funktion zu referenzieren. Dieses ist sinnvoll, wenn der Name der Funktion unbekannt ist. Auch in einer anonymen Funktion (ohne Namen) funktioniert dieses.</p>
+
+<div class="warning"><strong>Warnung</strong>: Die Version 5 von ECMAScript (ES5) verbietet die nutzung von <code>arguments.callee() im </code>{{jsxref("Strict_mode", "strict mode")}}. Der Einsatz von <code>arguments.callee() </code>soll vermieden werden, wenn function-Ausdrücke einen Namen haben oder Funktionen deklariert werden, die sich selbst aufrufen müssen.</div>
+
+<h3 id="Warum_wurde_arguments.callee_vom_ES5_strict_mode_entfernt">Warum wurde <code>arguments.callee</code> vom ES5 strict mode entfernt?</h3>
+
+<p>(angepasst von <a href="http://stackoverflow.com/a/235760/578288" title="http://stackoverflow.com/a/235760/578288">einer Stack Overflow-Antwort von olliej</a>)</p>
+
+<p>Frühe Versionen von JavaScript erlauben keine benamten Funktions-Anweisungen. Aus diesem Grund ist es nicht möglich rekursive Funktions-Anweisungen zu schreiben.</p>
+
+<p>Diese Syntax funktioniert, zum Beispiel:</p>
+
+<pre class="brush: js">function factorial (n) {
+    return !(n &gt; 1) ? 1 : factorial(n - 1) * n;
+}
+
+[1, 2, 3, 4, 5].map(factorial);</pre>
+
+<p>aber:</p>
+
+<pre class="brush: js">[1, 2, 3, 4, 5].map(function (n) {
+    return !(n &gt; 1) ? 1 : /* what goes here? */ (n - 1) * n;
+});</pre>
+
+<p>funktioniert nicht. Um dieses problem zu lösen wurde <code>arguments.callee</code> hinzugefügt.</p>
+
+<pre class="brush: js">[1, 2, 3, 4, 5].map(function (n) {
+    return !(n &gt; 1) ? 1 : arguments.callee(n - 1) * n;
+});</pre>
+
+<p>Allerdings ist dieses eine schlechte Lösung , weil diese (in Verbindung mit anderen <code>arguments</code>, <code>callee</code>, and <code>caller</code>-Problemen) inlining und Endrekursion unmöglich macht (man kann es benutzen um Tracing zu realisieren, jedoch ist der beste Code immer suboptimal). Ein weiteres Problem liegt darin, dass rekursive Aufrufe ein unterschiedliches <code>this</code> bekommen können (siehe folgendes Beispiel):</p>
+
+<pre class="brush: js">var global = this;
+
+var sillyFunction = function(recursed) {
+    if (!recursed) { return arguments.callee(true); }
+    if (this !== global) {
+        alert('This is: ' + this);
+    } else {
+        alert('This is the global');
+    }
+}
+
+sillyFunction();</pre>
+
+<p>ECMAScript 3 löste das Problem indem benamte Funktions-Ausdrücke erlaubt wurden:</p>
+
+<pre class="brush: js">[1, 2, 3, 4, 5].map(function factorial (n) {
+    return !(n &gt; 1) ? 1 : factorial(n - 1)*n;
+});</pre>
+
+<p>Dieses hat zahlreiche Vorteile:</p>
+
+<ul>
+ <li>Die Funktion kann wie jede andere Funktion im Code aufgerufen werden.</li>
+ <li>Es wird keine Variable im äußeren Gültigkeitsbereich erstellt (<a href="http://kangax.github.io/nfe/#example_1_function_expression_identifier_leaks_into_an_enclosing_scope">Ausnahme für IE 8 und kleiner</a>)</li>
+ <li>Es gibt eine bessere Performance wenn das arguments-Objekt genutzt wird</li>
+</ul>
+
+<p>Eine andere Funktion die verboten wurde ist <code>arguments.callee.caller</code> oder spezifischer <code>Function.caller</code>. Warum ist das so? Zu jedem Zeitpunkt ist es möglich, den tiefsten Aufrufer von jeder Funktion auf dem Stack herauszufinden und weil das herausfinden des Aufrufer-Stacks hat einen hauptsächlichen Effekt: Es macht das Optimieren unmöglich oder sehr viel schwerer. Zum Beispiel ist es nicht Möglich <code>f</code> zu inlinen, wenn nicht sichergestellt ist, dass eine Funktion <code>f</code> nicht eine unbekannte Funktion aufruft. Das bedeutet, dass jeder Aufruf eine große Anzahl an Sicherheitsabfragen durchführen müsste um inlinen zu können.</p>
+
+<pre class="brush: js">function f(a, b, c, d, e) { return a ? b * c : d * e; }</pre>
+
+<p>Wenn der JavaScript-Interpreter nicht garantieren kann, dass alle der unterstützten Argumente Nummern beim Aufruf sind, muss dieser Prüfungen für alle Argumente einfügen bevor der Code geinlinet werden kann oder die Funktion kann nicht geinlinet werden. In dieser Situation sollte ein guter Interpreter die Prüfungen neu anordnen, damit diese Optimal abgefragt werden und nur die Werte, die benutzt werden geprüft werden. Weil dieses in vielen Fällen nicht möglich ist, wird es in diesen unmöglich zu inlinen.</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Einsatz_von_arguments.callee_in_einer_anonymen_rekursiven_Funktion">Einsatz von <code>arguments.callee</code> in einer anonymen rekursiven Funktion</h3>
+
+<p>Eine rekursive Funktion muss sich selber aufrufen können. Normalerweise referenziert eine Funktion sich selbst mit dem Namen. Weil eine anonyme Funktion (welche von einem <a href="/de/docs/Web/JavaScript/Reference/Operators/function" title="JavaScript/Reference/Operators/Special/function">Funktionsausdruck</a> oder dem <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Function" title="JavaScript/Reference/Global_Objects/Function"><code>Function</code> Konstruktor</a> erstellt werden kann) hat keinen Namen. Wenn also keine Variable diese Funktion referenziert, ist der einzige Weg die Funktion über <code>arguments.callee</code> aufzurufen.</p>
+
+<p>Das folgende Beispiel definiert eine Funktion, welche wiederum eine Fakultätsfunktion Definiert und sie zurückgibt. Dieses Beispiel ist nicht sehr praktisch und es gibt fast keine Fälle, in denen dasselbe Ergebnis nicht mit <a href="/de/docs/Web/JavaScript/Reference/Operators/function">Funktionsausdrücken mit Namen</a> erreicht werden kann.</p>
+
+<pre class="brush: js">function create() {
+   return function(n) {
+      if (n &lt;= 1)
+         return 1;
+      return n * arguments.callee(n - 1);
+   };
+}
+
+var result = create()(5); // returns 120 (5 * 4 * 3 * 2 * 1)</pre>
+
+<h3 id="Der_einsatz_von_arguments.callee_mit_keinen_guten_Alternativen">Der einsatz von <code>arguments.callee</code> mit keinen guten Alternativen</h3>
+
+<p>In einem Fall wie dem Folgenden gibt es jedoch keine Alternativen zu arguments.callee, so dass seine Veraltung ein Fehler sein könnte (siehe {{Bug("725398")}}):</p>
+
+<pre class="brush: js">function createPerson(sIdentity) {
+    var oPerson = new Function('alert(arguments.callee.identity);');
+    oPerson.identity = sIdentity;
+    return oPerson;
+}
+
+var john = createPerson('John Smith');
+
+john();</pre>
+
+<h2 id="Spezifikationen">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. Implementiert in JavaScript 1.2</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.functions.arguments.callee")}}</p>
+
+<h2 id="See_also" name="See_also">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Function")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/functions/arguments/index.html b/files/de/web/javascript/reference/functions/arguments/index.html
new file mode 100644
index 0000000000..180a53dc5f
--- /dev/null
+++ b/files/de/web/javascript/reference/functions/arguments/index.html
@@ -0,0 +1,223 @@
+---
+title: Arguments object
+slug: Web/JavaScript/Reference/Functions/arguments
+tags:
+  - Functions
+  - JavaScript
+  - Reference
+  - arguments
+translation_of: Web/JavaScript/Reference/Functions/arguments
+---
+<div>
+<div>
+<div>{{jsSidebar("Functions")}}</div>
+</div>
+</div>
+
+<p>Das <strong><code>arguments</code></strong>-Objekt ist ein Array-ähnliches Objekt, das auf die übergebenen Parameter einer Funktion verweist.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/functions-arguments.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox notranslate">arguments</pre>
+
+<h2 id="Description" name="Description">Beschreibung</h2>
+
+<p>Das <code>arguments</code>-Objekt ist eine lokal verfügbare Variable in allen (Nicht-Pfeil-) Funktionen. Man kann auf die Parameter einer Funktion referenzieren, wenn man in einer Funktion das <code>arguments</code>-Objekt benutzt. Dieses Objekt enthält einen Eintrag für jeden übergebenen Parameter der Funktion. Der erste Eintrag beginnt beim Index 0. Wenn einer Funktion drei Parameter übergeben werden, kann wie folgt auf diese zugegriffen werden;</p>
+
+<pre class="brush: js notranslate">arguments[0]
+arguments[1]
+arguments[2]
+</pre>
+
+<p>Die Parameter können auch überschrieben werden:</p>
+
+<pre class="brush: js notranslate">arguments[1] = 'new value';</pre>
+
+<p>Das <code>arguments</code>-Objekt ist kein {{jsxref("Array")}}. Es ist ähnlich wie ein <code>Array</code>, hat aber keine Eigenschaften eines <code>Array</code>s mit <span class="dpf_sent" id="dpfsent_1">Ausnahme </span>von {{jsxref("Functions/arguments/length", "length")}}. Zum Beispiel ist die {{jsxref("Global_Objects/Array/pop", "pop")}}-Methode nicht vorhanden. Jedoch kann <code>arguments</code> zu einem echten <code>Array</code> konvertiert werden:</p>
+
+<pre class="brush: js notranslate">var args = Array.prototype.slice.call(arguments);
+var args = [].slice.call(arguments);
+
+// ES2015
+const args = Array.from(arguments);</pre>
+
+<div class="warning">
+<p>Der Einsatz von slice auf arguments kann Optimierungen bei einigen JavaScript-Engines (z. B. bei V8 — <a href="https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments">mehr Informationen</a>) verhindern. Wenn man sich darum kümmert, sollte ein neues Array erstellt werden, indem über das arguments-Objekt iteriert wird. Eine Alternative ist der Einsatz von <code>Array.apply</code> wie folgt:</p>
+
+<pre class="brush: js notranslate">var args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments));)</pre>
+</div>
+
+<p>Man kann das <code>arguments</code>-Objekt nutzen, um eine Funktion mit mehr übergebenen Parametern, als die der formalen Definition, zu verarbeiten. Diese Technik ist hilfreich für Funktionen mit variabler Parameteranzahl. Man kann {{jsxref("Functions/arguments/length", "arguments.length")}} nutzen, um die Anzahl der übergebenen Parameter festzustellen und dann jeden Parameter über das <code>arguments</code>-Objekt zu verarbeiten. (Um die Anzahl der deklarierten Parameter festzustellen, kann die {{jsxref("Functions/length", "Funktion.length")}} Eigenschaft genutzt werden.)</p>
+
+<h3 id="Einsatz_von_typeof_bei_arguments">Einsatz von <code>typeof</code> bei arguments</h3>
+
+<p>Der Typ von <code>arguments</code> ist <code>'object'</code></p>
+
+<pre class="brush: js notranslate">console.log(typeof arguments); // 'object'</pre>
+
+<p>Der Typ von individuellen Argumenten kann über den Index ermittelt werden.</p>
+
+<pre class="brush: js notranslate">console.log(typeof arguments[0]); // Gibt den Typ des individuellen Arguments zurück</pre>
+
+<h3 id="Einsatz_der_Spread_Syntax_mit_arguments">Einsatz der Spread Syntax mit arguments</h3>
+
+<p>Man kann die {{jsxref("Array.from()")}} Methode oder den <a href="/de/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a> nutzen, um arguments zu einem echten Array zu konvertieren:</p>
+
+<pre class="brush: js notranslate">var args = Array.from(arguments);
+var args = [...arguments];</pre>
+
+<h2 id="Properties" name="Properties">Eigenschaften</h2>
+
+<dl>
+ <dt>{{jsxref("Functions/arguments/callee", "arguments.callee")}}</dt>
+ <dd>Referenz zur aktuell ausgeführten Funktion.</dd>
+ <dt>{{jsxref("Functions/arguments/caller", "arguments.caller")}} {{ Obsolete_inline() }}</dt>
+ <dd>Referenz zur Funktion, die die aktuelle Funktion ausführt hat.</dd>
+ <dt>{{jsxref("Functions/arguments/length", "arguments.length")}}</dt>
+ <dd>Anzahl der übergebenen Funktionsparameter.</dd>
+ <dt>{{jsxref("Functions/arguments/@@iterator", "arguments[@@iterator]")}}</dt>
+ <dd>Gibt ein Array-Iterator-Objekt zurück, welches die Werte an allen Indizes von arguments enthält.</dd>
+</dl>
+
+<h2 id="Examples" name="Examples">Beispiele</h2>
+
+<h3 id="Example_Defining_function_that_concatenates_several_strings" name="Example:_Defining_function_that_concatenates_several_strings">Definition einer Funktion, die mehrere Strings <span class="dpf_sent" id="dpfsent_1">konkateniert</span></h3>
+
+<p>Dieses Beispiel definiert eine Funktion, die mehrere Strings <span class="dpf_sent" id="dpfsent_1">konkateniert</span>. Der einzige formale Parameter der Funktion ist ein String, der die Zeichen enthält, die die einzelnen Elemente trennt. Die Funktion ist wie folgt definiert:</p>
+
+<pre class="brush:js notranslate">function myConcat(separator) {
+  var args = Array.prototype.slice.call(arguments, 1);
+  return args.join(separator);
+}</pre>
+
+<p>Man kann eine beliebige Anzahl von Parametern der Funktion <span class="dpf_sent" id="dpfsent_0">übergeben</span> und es wird jedes Argument für den String eingesetzt.</p>
+
+<pre class="brush:js notranslate">// returns "red, orange, blue"
+myConcat(", ", "red", "orange", "blue");
+
+// returns "elephant; giraffe; lion; cheetah"
+myConcat("; ", "elephant", "giraffe", "lion", "cheetah");
+
+// returns "sage. basil. oregano. pepper. parsley"
+myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");</pre>
+
+<h3 id="Example_Defining_a_function_that_creates_HTML_lists" name="Example:_Defining_a_function_that_creates_HTML_lists">Definition einer Funktion, die HTML-Listen erstellt</h3>
+
+<p>Im Beispiel wird eine Funktion definiert, die einen String mit HTML für eine Liste zurückgibt. Der einzige formale Parameter der Funktion ist ein String, der "<code>u</code>" für eine ungeordnete Liste oder "<code>o</code>" für eine geordnete Liste enthält. Die Funktion ist wie folgt definiert:</p>
+
+<pre class="brush:js notranslate">function list(type) {
+  var result = "&lt;" + type + "l&gt;&lt;li&gt;";
+  var args = Array.prototype.slice.call(arguments, 1);
+  result += args.join("&lt;/li&gt;&lt;li&gt;");
+  result += "&lt;/li&gt;&lt;/" + type + "l&gt;"; // end list
+
+  return result;
+}</pre>
+
+<p>Der Funktion kann eine variable Anzahl an Parametern übergeben werden und es wird jeder Parameter als Listeneintrag einer Liste hinzugefügt. Zum Beispiel:</p>
+
+<pre class="brush:js notranslate">var listHTML = list("u", "One", "Two", "Three");
+
+/* listHTML is:
+
+"&lt;ul&gt;&lt;li&gt;One&lt;/li&gt;&lt;li&gt;Two&lt;/li&gt;&lt;li&gt;Three&lt;/li&gt;&lt;/ul&gt;"
+
+*/</pre>
+
+<h3 id="Rest_default_und_Destrukturierende_Parameter">Rest, default und Destrukturierende Parameter</h3>
+
+<p>Das <code>arguments</code>-Objekt kann in Verbindung mit <a href="/de/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/de/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, und <a href="/de/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destrukturierenden</a> Parametern eingesetzt werden.</p>
+
+<pre class="brush: js notranslate">function foo (...args) {
+  return args;
+}
+foo(1, 2, 3); // [1,2,3]</pre>
+
+<p>Wenn der Einsatz von <a href="/de/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/de/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, und <a href="/de/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destrukturierenden</a> Parametern nicht die <a href="/de/docs/Web/JavaScript/Reference/Strict_mode#Making_eval_and_arguments_simpler">die Eigenschaften des <code>arguments</code> Objekts verändert, gibt es eine Unterschied zwischen dem strict mode</a> und dem nicht strict mode.</p>
+
+<p>Wenn eine nicht-strikte (non-strict) Funktion nicht  <a href="/de/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/de/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, oder <a href="/de/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destrukturierende</a> Parameter enthält, referenzieren die Werte des <code>arguments</code> Objektes direkt auf die deklarierten Parameter und umgekehrt. Siehe dazu folgenden Quelltext:</p>
+
+<pre class="brush: js notranslate">function func (a) {
+  arguments[0] = 99; // Aktualisert auch arguments[0] und a
+  console.log(a);
+}
+func(10); // 99</pre>
+
+<p>und</p>
+
+<pre class="brush: js notranslate">function func (a) {
+  a = 99; // Aktualisert auch arguments[0] und a
+  console.log(arguments[0]);
+}
+func(10); // 99</pre>
+
+<p>Wenn eine nicht-strikte (non-strict) Funktion <a href="/de/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/de/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, oder <a href="/de/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destrukturierende</a> Parameter enthält, referenzieren die Werte des <code>arguments</code> Objektes <strong>nicht</strong> direkt auf die deklarierten Parameter und umgekehrt. Die Werte in <code>arguments</code> sind die Werte, die der Funktion beim Aufruf übergeben werden:</p>
+
+<pre class="brush: js notranslate">function func(a = 55) {
+  arguments[0] = 99; // aktualisert arguments[0] aber nicht a
+  console.log(a);
+}
+func(10); // 10</pre>
+
+<p>und</p>
+
+<pre class="brush: js notranslate">function func(a = 55) {
+  a = 99; // aktualisert a aber nicht arguments[0]
+  console.log(arguments[0]);
+}
+func(10); // 10;</pre>
+
+<p>und</p>
+
+<pre class="brush: js notranslate">function func(a = 55) {
+  console.log(arguments[0]);
+}
+func(); // undefined;</pre>
+
+<h2 id="Spezifikationen">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. Implementiert in JavaScript 1.1</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.functions.arguments")}}</p>
+
+<h2 id="See_also" name="See_also">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Function")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/functions/arguments/length/index.html b/files/de/web/javascript/reference/functions/arguments/length/index.html
new file mode 100644
index 0000000000..a2da4718b4
--- /dev/null
+++ b/files/de/web/javascript/reference/functions/arguments/length/index.html
@@ -0,0 +1,87 @@
+---
+title: arguments.length
+slug: Web/JavaScript/Reference/Functions/arguments/length
+tags:
+  - Functions
+  - JavaScript
+  - Property
+  - arguments
+translation_of: Web/JavaScript/Reference/Functions/arguments/length
+---
+<div>
+<div>{{jsSidebar("Functions")}}</div>
+</div>
+
+<p>Die <strong><code>arguments.length</code></strong>-Eigenschaft <span class="dpf_sent" id="dpfsent_1">enthält </span>die Anzahl der übergebenen Parameter einer Funktion.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">arguments.length</pre>
+
+<h2 id="Description" name="Description">Beschreibung</h2>
+
+<p>Die <code>arguments.length</code>-Eigenschaft <span class="dpf_sent" id="dpfsent_1">enthält </span>die Anzahl der Parameter, die der aktuellen Funktion übergeben wurden. Diese Anzahl kann größer oder kleiner der Anzahl der definierten Parameter sein (siehe {{jsxref("Function.length")}}).</p>
+
+<h2 id="Examples" name="Examples">Beispiele</h2>
+
+<h3 id="Example:_Using_arguments.length" name="Example:_Using_arguments.length">Beispiel: <code>arguments.length</code> nutzen</h3>
+
+<p>In diesem Beispiel wird eine Funktion definiert, die zwei oder mehr Nummern addieren kann.</p>
+
+<pre class="brush: js">function adder(base /*, n2, ... */) {
+  base = Number(base);
+  for (var i = 1; i &lt; arguments.length; i++) {
+    base += Number(arguments[i]);
+  }
+  return base;
+}
+</pre>
+
+<div class="note">
+<p>Zu beachten ist der Unterschied zwischen {{jsxref("Function.length")}} und arguments.length</p>
+</div>
+
+<h2 id="Spezifikationen">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 Definietion. Implementiert in JavaScript 1.1</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.functions.arguments.length")}}</p>
+
+<h2 id="See_also" name="See_also">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Function")}}</li>
+ <li>{{jsxref("Function.length")}}</li>
+</ul>