aboutsummaryrefslogtreecommitdiff
path: root/files/de/web/javascript/reference/functions
diff options
context:
space:
mode:
authorPeter Bengtsson <mail@peterbe.com>2020-12-08 14:41:15 -0500
committerPeter Bengtsson <mail@peterbe.com>2020-12-08 14:41:15 -0500
commit4b1a9203c547c019fc5398082ae19a3f3d4c3efe (patch)
treed4a40e13ceeb9f85479605110a76e7a4d5f3b56b /files/de/web/javascript/reference/functions
parent33058f2b292b3a581333bdfb21b8f671898c5060 (diff)
downloadtranslated-content-4b1a9203c547c019fc5398082ae19a3f3d4c3efe.tar.gz
translated-content-4b1a9203c547c019fc5398082ae19a3f3d4c3efe.tar.bz2
translated-content-4b1a9203c547c019fc5398082ae19a3f3d4c3efe.zip
initial commit
Diffstat (limited to 'files/de/web/javascript/reference/functions')
-rw-r--r--files/de/web/javascript/reference/functions/arguments/@@iterator/index.html78
-rw-r--r--files/de/web/javascript/reference/functions/arguments/callee/index.html157
-rw-r--r--files/de/web/javascript/reference/functions/arguments/index.html223
-rw-r--r--files/de/web/javascript/reference/functions/arguments/length/index.html87
-rw-r--r--files/de/web/javascript/reference/functions/default_parameters/index.html223
-rw-r--r--files/de/web/javascript/reference/functions/get/index.html174
-rw-r--r--files/de/web/javascript/reference/functions/index.html594
-rw-r--r--files/de/web/javascript/reference/functions/methoden_definitionen/index.html230
-rw-r--r--files/de/web/javascript/reference/functions/pfeilfunktionen/index.html360
-rw-r--r--files/de/web/javascript/reference/functions/rest_parameter/index.html167
-rw-r--r--files/de/web/javascript/reference/functions/set/index.html149
11 files changed, 2442 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>
diff --git a/files/de/web/javascript/reference/functions/default_parameters/index.html b/files/de/web/javascript/reference/functions/default_parameters/index.html
new file mode 100644
index 0000000000..6e88aaa134
--- /dev/null
+++ b/files/de/web/javascript/reference/functions/default_parameters/index.html
@@ -0,0 +1,223 @@
+---
+title: Default parameters
+slug: Web/JavaScript/Reference/Functions/Default_parameters
+tags:
+ - ECMAScript 2015
+ - Functions
+ - JavaScript
+translation_of: Web/JavaScript/Reference/Functions/Default_parameters
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p><strong>Standard Funktionsparameter</strong> erlaubt es formale Parameter mit vorgegebenen Werten zu initialisieren, wenn beim Funktionsaufruf kein Wert oder <code>undefined</code> übergeben wird.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/functions-default.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="brush: js">function [<em>name</em>]([<em>param1</em>[ = defaultValue1 ][, ..., <em>paramN</em>[ = defaultValueN ]]]) {
+ <em>statements</em>
+}
+</pre>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>In JavaScript haben Funktionsparameter standardmäßig den Default-Wert {{jsxref("undefined")}}. Manchmal ist es jedoch sinnvoll einen anderen Default-Wert zu setzen. Hier helfen Default-Parameter weiter.</p>
+
+<p>In der Vergangenheit war die allgemeine Strategie für das Setzen von Default-Werten das Testen von Parameterwerten im Body der Funktion und dem Zuordnen eines Default-Wertes, wenn dieser <code>undefined</code> ist. Wenn in dem folgenden Beispiel bei dem Aufruf kein Wert für <code>b</code> mitgegeben wird, würde der Wert <code>undefined</code> sein. Bei der Auswertung von <code>a*b</code> und dem Aufruf von <code>multiply</code> wird als Rückgabewert <code>NaN</code> zurückgegeben. Im Beispiel wird deshalb dieser Rückgabewert in der zweiten Zeile der Funktion aufgefangen:</p>
+
+<pre class="brush: js">function multiply(a, b) {
+ b = (typeof b !== 'undefined') ? b : 1;
+ return a * b;
+}
+
+multiply(5, 2); // 10
+multiply(5, 1); // 5
+multiply(5); // 5
+</pre>
+
+<p>Mit dem Default-Parameter in ES2015 ist die Prüfung im Funktionskörper nicht mehr nötig. Jetzt kann man einfach <code>1</code> als den Standardwert für <code>b</code> in dem Funktionskopf definieren: </p>
+
+<pre class="brush: js">function multiply(a, b = 1) {
+ return a * b;
+}
+
+multiply(5, 2); // 10
+multiply(5, 1); // 5
+multiply(5); // 5
+</pre>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Übergeben_von_undefined_und_anderen_falsy_Werten">Übergeben von <code>undefined</code> und anderen falsy Werten</h3>
+
+<p>In dem zweiten Aufruf, auch wenn das erste Argument explizit auf <code>undefined</code> gesetzt ist (jedoch nicht <code>null</code> oder andere {{Glossary("Falsy", "Falsy-Werte")}}, ist der Wert des Arguments <code>num</code> beim Aufruf der Default-Wert.</p>
+
+<pre class="brush: js">function test(num = 1) {
+ console.log(typeof num);
+}
+
+test(); // 'number' (num wird auf 1 gesetzt)
+test(undefined); // 'number' (num wird auf 1 gesetzt)
+
+// test with other falsy values:
+test(''); // 'string' (num wird auf '' gesetzt)
+test(null); // 'object' (num wird auf null gesetzt)
+</pre>
+
+<h3 id="Auswerten_beim_Aufruf">Auswerten beim Aufruf</h3>
+
+<p>Das Standard-Argument wird zum Zeitpunkt des Aufrufs ausgewertet. Somit wird - anders als z.B. in Python - ein neues Objekt bei jedem Funktionsaufruf erzeugt.</p>
+
+<pre class="brush: js">function append(value, array = []) {
+ array.push(value);
+ return array;
+}
+
+append(1); //[1]
+append(2); //[2], nicht [1, 2]
+</pre>
+
+<p>Das Gleiche gilt für Funktionen und Variablen:</p>
+
+<pre class="brush: js">function callSomething(thing = something()) {
+ return thing;
+}
+
+function something(){
+ return "sth";
+}
+
+callSomething(); //sth</pre>
+
+<h3 id="Default-Parameter_stehen_nachfolgenden_Default-Parametern_zur_Verfügung">Default-Parameter stehen nachfolgenden Default-Parametern zur Verfügung</h3>
+
+<p>Die bereits angetroffenen Parameter stehen den späteren Standardparametern zur Verfügung:</p>
+
+<pre class="brush: js">function singularAutoPlural(singular, plural = singular+"s",
+ rallyingCry = plural + " ATTACK!!!") {
+ return [singular, plural, rallyingCry ];
+}
+
+//["Gecko","Geckos", "Geckos ATTACK!!!"]
+singularAutoPlural("Gecko");
+
+//["Fox","Foxes", "Foxes ATTACK!!!"]
+singularAutoPlural("Fox","Foxes");
+
+//["Deer", "Deer", "Deer ... change."]
+singularAutoPlural("Deer", "Deer", "Deer peaceably and respectfully
+ petition the government for positive change.")
+</pre>
+
+<p>Diese Funktionalität wird in einer geradlinigen Weise angenähert und zeigt, wie viele Randfälle behandelt werden:</p>
+
+<pre class="brush: js">function go() {
+ return ":P"
+}
+
+function withDefaults(a, b = 5, c = b, d = go(), e = this,
+ f = arguments, g = this.value) {
+ return [a,b,c,d,e,f,g];
+}
+
+function withoutDefaults(a, b, c, d, e, f, g){
+ switch(arguments.length){
+ case 0:
+ a
+ case 1:
+ b = 5
+ case 2:
+ c = b
+ case 3:
+ d = go();
+ case 4:
+ e = this
+ case 5:
+ f = arguments
+ case 6:
+ g = this.value;
+ default:
+ }
+ return [a,b,c,d,e,f,g];
+}
+
+withDefaults.call({value:"=^_^="});
+// [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="]
+
+
+withoutDefaults.call({value:"=^_^="});
+// [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="]
+</pre>
+
+<h3 id="Funktionen_definiert_innerhalb_des_Funktionskörpers">Funktionen definiert innerhalb des Funktionskörpers</h3>
+
+<p>Eingeführt in Gecko 33 {{geckoRelease(33)}}. Funktionen die innerhalb eines Funktionskörper deklariert werden, können nicht von Default-Parametern referenziert werden und führen zu einem {{jsxref("ReferenceError")}} (aktuell wird ein {{jsxref("TypeError")}} erzeugt, siehe {{bug(1022967)}}). Default-Parameter werden stets zuerst ausgewertet, Funktionsdeklarationen innerhalb von Funktionskörpern erst hinterher.</p>
+
+<pre class="brush: js">// Funktioniert nicht! Wirft einen ReferenceError.
+function f(a = go()) {
+ function go(){return ":P"}
+}
+</pre>
+
+<h3 id="Paramater_ohne_Default_nach_Default-Parameter">Paramater ohne Default nach Default-Parameter</h3>
+
+<p>Vor Gecko 26 {{geckoRelease(26)}} erzeugte der folgende Code einen {{jsxref("SyntaxError")}}. Dieses wurde in {{bug(777060)}} behoben und funktioniert wie erwartet in späteren Versionen. Bei Aufruf werden Parameter noch immer von links nach rechts angegeben. Default-Parameter werden überschrieben, auch wenn spätere Parameter keinen Default haben:</p>
+
+<pre class="brush: js">function f(x=1, y) {
+ return [x, y];
+}
+
+f(); // [1, undefined]
+f(2); // [2, undefined]
+</pre>
+
+<h3 id="Zerstörter_Parameter_mit_Standardwertzuordnung">Zerstörter Parameter mit Standardwertzuordnung</h3>
+
+<p>Sie können die Standardwertzuordnung mit der <a href="/de/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destrukturierende Zuordnung</a> Schreibweise verwenden:</p>
+
+<pre class="brush: js">function f([x, y] = [1, 2], {z: z} = {z: 3}) {
+ return x + y + z;
+}
+
+f(); // 6</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('ES2015', '#sec-function-definitions', 'Function Definitions')}}</td>
+ <td>{{Spec2('ES2015')}}</td>
+ <td>Initiale Definition.</td>
+ </tr>
+ <tr>
+ <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function Definitions')}}</td>
+ <td>{{Spec2('ESDraft')}}</td>
+ <td> </td>
+ </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div>
+
+
+<p>{{Compat("javascript.functions.default_parameters")}}</p>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li><a href="http://wiki.ecmascript.org/doku.php?id=harmony:parameter_default_values" rel="external" title="http://wiki.ecmascript.org/doku.php?id=harmony:parameter_default_values">Original Vorschlag von ecmascript.org</a></li>
+</ul>
diff --git a/files/de/web/javascript/reference/functions/get/index.html b/files/de/web/javascript/reference/functions/get/index.html
new file mode 100644
index 0000000000..b36b0f50e8
--- /dev/null
+++ b/files/de/web/javascript/reference/functions/get/index.html
@@ -0,0 +1,174 @@
+---
+title: Getter
+slug: Web/JavaScript/Reference/Functions/get
+tags:
+ - ECMAScript 2015
+ - ECMAScript 5
+ - Functions
+ - JavaScript
+ - Language feature
+translation_of: Web/JavaScript/Reference/Functions/get
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p>Die <strong><code>get</code></strong> Syntax bindet eine Objekteigenschaft an eine Funktion welche aufgerufen wird, wenn die Eigenschaft abgefragt wird.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/functions-getter.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">{get <var>prop</var>() { ... } }
+{get [<var>expression</var>]() { ... } }</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>Der Name der Eigenschaft, die an die gegebene Funktion gebunden wird.</dd>
+ <dt><code><var>expression</var></code></dt>
+ <dd>Beginnend mit ECMAScript 2015, kann auch ein Ausdruck für einen berechneten Eigenschaftsnamen genutzt werden, der an die Funktion gebunden wird.</dd>
+</dl>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Manchmal ist es wünschenswert, den Zugriff auf eine Eigenschaft zuzulassen, die einen dynamisch berechneten Wert zurückgibt oder man möchten den Status einer internen Variablen widerspiegeln, ohne dass explizite Methodenaufrufe erforderlich sind. In JavaScript kann dieses mit einem <em>getter</em> erreicht werden.</p>
+
+<p>Es ist nicht möglich, dass ein Getter gleichzeitig an eine Eigenschaft gebunden ist und diese Eigenschaft tatsächlich einen Wert enthält, obwohl es möglich ist, einen Getter und einen Setter in Verbindung zu verwenden, um einen Pseudoeigenschaftstyp zu erstellen.</p>
+
+<p>Folgendes ist zu beachten, wenn die <code>get</code> Syntax verwendet wird:</p>
+
+<ul>
+ <li>Sie kann ein Bezeichner haben, welche entweder eine Zahl oder ein String ist.</li>
+ <li>Sie muss exakt null Parameter haben (siehe <a class="external" href="http://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/" rel="external nofollow">Incompatible <abbr title="ECMAScript 5th edition">ES5</abbr> change: literal getter and setter functions must now have exactly zero or one arguments</a> für mehr Informationen);</li>
+ <li>Es darf nicht in einem Objektliteral mit einem anderen <code>get</code> oder Dateneintrag für die gleiche Eigenschaft benutzt werden (<code>{ get x() { }, get x() { } }</code> und <code>{ x: ..., get x() { } }</code> sind verboten).</li>
+</ul>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Definition_eines_Getters_in_einem_neuen_Objekt_in_der_Objektinitialisierung">Definition eines Getters in einem neuen Objekt in der Objektinitialisierung</h3>
+
+<p>Folgendes erstellt eine Pseudoeigenschaft <code>latest</code> für das Objekt <code>obj</code>, welche dan letzte Arrayeintrag von <code>log</code> zurückgibt.</p>
+
+<pre class="brush: js">const obj = {
+ log: ['example','test'],
+ get latest() {
+ if (this.log.length === 0) return undefined;
+ return this.log[this.log.length - 1];
+ }
+}
+console.log(obj.latest); // "test".
+</pre>
+
+<p>Zu beachten ist, dass die Zuweisung eines Wertes auf <code>latest</code> keine Änderung bewirkt.</p>
+
+<h3 id="Löschen_eines_Getters_mit_dem_delete_Operator">Löschen eines Getters mit dem <code>delete</code> Operator</h3>
+
+<p>Wenn ein Getter gelöscht werden soll, kann einfach {{jsxref("Operators/delete", "delete")}} benutzt werden:</p>
+
+<pre class="brush: js">delete <var>obj</var>.latest;
+</pre>
+
+<h3 id="Definition_eines_Getter_auf_einem_existierenden_Objektes_mit_defineProperty">Definition eines Getter auf einem existierenden Objektes mit <code>defineProperty</code></h3>
+
+<p>Um einem Getter später zu einem existierenden Objekt hinzuzufügen, kann jederzeit {{jsxref("Object.defineProperty()")}} benutzt werden.</p>
+
+<pre class="brush: js">const o = {a: 0};
+
+Object.defineProperty(o, 'b', { get: function() { return this.a + 1; } });
+
+console.log(o.b) // Runs the getter, which yields a + 1 (which is 1)</pre>
+
+<h3 id="Einen_berechneten_Eigenschaftnamen_benutzen">Einen berechneten Eigenschaftnamen benutzen</h3>
+
+<pre class="brush: js">const expr = 'foo';
+
+const obj = {
+ get [expr]() { return 'bar'; }
+};
+
+console.log(obj.foo); // "bar"</pre>
+
+<h3 id="Intelligente_Selbstüberschreibende_Lazy_Getter">Intelligente / Selbstüberschreibende / Lazy Getter</h3>
+
+<p>Mit Gettern kann eine Eigenschaft eines Objekts <em>definiert</em> werden, wobei der Wert der Eigenschaft nicht <em>berechnen</em> wird, bis auf die Eigenschaft zugegriffen wird. Ein Getter verschiebt die Kosten für die Berechnung des Werts auf den Zeitpunkt des Zugriffs. Wenn der der Getter nie benötigt wird, fallen nie Kosten an.</p>
+
+<p>Eine weitere Optimierungstechnik, um die Berechnung eines Eigenschaftswerts zu verzögern und ihn für einen späteren Zugriff zwischenzuspeichern, sind <strong>intelligente (oder "<a href="https://de.wikipedia.org/wiki/Memoisation">memoisierte</a>") Getter</strong>. Der Wert wird berechnet, wenn der Getter das erste Mal aufgerufen wird und wird dann zwischengespeichert, damit nachfolgende Zugriffe den zwischengespeicherten Wert zurückgeben, ohne ihn neu zu berechnen. Dies ist in den folgenden Situationen nützlich:</p>
+
+<ul>
+ <li>Wenn die Berechnung eines Eigenschaftswerts teuer ist (erfordert viel RAM- oder CPU-Zeit, erzeugen von Worker-Threads, ruft eine Remote-Datei ab usw.).</li>
+ <li>Wenn der Wert gerade nicht benötigt wird. Er wird später verwendet oder in einigen Fällen wird er überhaupt nicht verwendet.</li>
+ <li>Wenn er verwendet wird, wird mehrmals darauf zugegriffen und er ist nicht erforderlich, den Wert neu zu berechnen, da er nie geändert oder nicht neu berechnet wird.</li>
+</ul>
+
+<div class="note">
+<p>Das bedeutet, dass keine verzögerten Getter für eine Eigenschaft verwenden werden sollten, deren Wert sich voraussichtlich ändern wird, weil der Getter den Wert nicht neu berechnet.</p>
+</div>
+
+<p>Im folgenden Beispiel hat das Objekt einen Getter als eigene Eigenschaft. Beim Abrufen der Eigenschaft wird die Eigenschaft aus dem Objekt entfernt und erneut hinzugefügt, diesmal jedoch implizit als Dateneigenschaft. Abschließend wird der Wert zurückgegeben.</p>
+
+<pre class="brush: js">get notifier() {
+ delete this.notifier;
+ return this.notifier = document.getElementById('bookmarked-notification-anchor');
+},</pre>
+
+<p>Für Firefox Code sollte zusätzlich das <code>XPCOMUtils.jsm</code> Code Modul angeschaut werden, welches die <code><a href="/de/docs/Mozilla/JavaScript_code_modules/XPCOMUtils.jsm#defineLazyGetter()">defineLazyGetter()</a></code> Funktion definiert.</p>
+
+<h3 id="get_vs._defineProperty"><code>get</code> vs. <code>defineProperty</code></h3>
+
+<p>Das <code>get</code> Schlüsselwort und {{jsxref("Object.defineProperty()")}} haben ähnliche Ergebnisse. Es gibt einen kleinen Unterschied zwischen beiden, wenn {{jsxref("classes")}} eingesetzt werden.</p>
+
+<p>Wenn <code>get</code> eingesetzt wird, wird die Eigenschaft im Instnaz-Prototyp definiert, während beim Einsatz von {{jsxref("Object.defineProperty()")}} die Eigenschaft auf der Instanz definiert wird.</p>
+
+<pre class="brush: js">class Example {
+ get hello() {
+ return 'world';
+ }
+}
+
+const obj = new Example();
+console.log(obj.hello);
+// "world"
+
+console.log(Object.getOwnPropertyDescriptor(obj, 'hello'));
+// undefined
+
+console.log(
+ Object.getOwnPropertyDescriptor(
+ Object.getPrototypeOf(obj), 'hello'
+ )
+);
+// { configurable: true, enumerable: false, get: function get hello() { return 'world'; }, set: undefined }</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <thead>
+ <tr>
+ <th scope="col">Spezifikation</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td>
+ </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.functions.get")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li><a href="/de/docs/Web/JavaScript/Reference/Functions/set">setter</a></li>
+ <li>{{jsxref("Operators/delete", "delete")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.defineGetter", "__defineGetter__")}}</li>
+ <li>{{jsxref("Object.defineSetter", "__defineSetter__")}}</li>
+ <li><a href="/de/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">Defining Getters and Setters</a> im JavaScript Guide</li>
+</ul>
diff --git a/files/de/web/javascript/reference/functions/index.html b/files/de/web/javascript/reference/functions/index.html
new file mode 100644
index 0000000000..278d3e997d
--- /dev/null
+++ b/files/de/web/javascript/reference/functions/index.html
@@ -0,0 +1,594 @@
+---
+title: Funktionen
+slug: Web/JavaScript/Reference/Functions
+tags:
+ - Constructor
+ - Function
+ - Functions
+ - JavaScript
+ - Parameter
+ - parameters
+translation_of: Web/JavaScript/Reference/Functions
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p>Allgemein gesagt, ist eine Funktion ein "Unterprogramm", welches von Code außerhalb der Funktion (oder innerhalb der Funktion, im Fall von Rekursion) aufgerufen wird. Wie Programme selbst auch, ist eine Funktion eine Sequenz von ausgewählten Statements, die als Funktionskörper bezeichnet wird. Der Funktion können der Werte übergeben werden und die Funktion wird einen Wert zurückgeben.</p>
+
+<p>In JavaScript sind Funktionen First-Class Objekte, weil sie Eigenschaften und Methoden genau wie jedes andere Objekt haben können. Was sie von anderen Objekten unterscheidet ist, dass sie aufgerufen werden können. Kurz gesagt sind es <code><a href="/de/docs/JavaScript/Reference/Global_Objects/Function">Function</a></code> Objekte.</p>
+
+<p>Für mehr Beispiele und Erklärungen, siehe auch im <a href="/de/docs/Web/JavaScript/Guide/Functions">JavaScript Guide über Funktionen</a>.</p>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Jede Funktion in JavaScript ist ein <code>Function</code> Objekt. Siehe {{jsxref("Function")}} für mehr Informationen zu Eigenschaften und Methoden von <code>Function</code> Objekten.</p>
+
+<p>Um einen Wert abweichend vom Standard zurückzugeben, muss eine Funktion ein <code><a href="/de/docs/Web/JavaScript/Reference/Statements/return">return</a></code> Statement haben, welches den Rückgabewert spezifiziert. Eine Funktion ohne ein return Statement wird den Standardwert zurückgeben. Im Fall eines <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor">Konstruktor</a>aufrufes mit dem Schlüsselwort <code><a href="/de/docs/Web/JavaScript/Reference/Operators/new">new</a></code>, wird der als Standardwert der Wert vom <code>this</code> Parameter zurückgegeben. Für alle anderen Funktionen wird als Standardwert {{jsxref("undefined")}} zurückgegeben.</p>
+
+<p>Die Parameter eines Funktionsaufrufes sind die Argumente der Funktion. Argumente werden als Werte der Funktion übergeben. Wenn die Funktion den Wert eines Argumentes ändert, wirkt sich die Änderung nicht global oder in der aufrufenden Funktion aus. Jedoch sind auch Objektreferenzen Werte, welche speziell sind: Wenn die Funktion die Eigenschaften eines referenzierte Objekts ändern, ist die Änderung außerhalb der Funktion sichtbar, wie im folgenden Beispiel gezeigt wird:</p>
+
+<pre class="brush: js notranslate">/* Deklariert die Funktion 'myFunc' */
+function myFunc(theObject) {
+ theObject.brand = "Toyota";
+}
+
+/*
+ * Deklariert die Variable 'mycar';
+ * Erstellt und initialisiert ein neues Objekt;
+ * Weist Referenz 'mycar' zu
+ */
+var mycar = {
+ brand: "Honda",
+ model: "Accord",
+ year: 1998
+};
+
+/* gibt 'Honda' aus */
+console.log(mycar.brand);
+
+/* Übergibt Objektreferenz der Funktion */
+myFunc(mycar);
+
+/*
+ * gibt 'Toyota' als Wert der 'brand' Eigenschaft
+ * des Objektes aus, so wie er von der Funktion geändert wurde.
+ */
+console.log(mycar.brand);
+</pre>
+
+<p>Das <a href="/de/docs/Web/JavaScript/Reference/Operators/this"><code>this</code> Schlüsselwort</a> referenziert nicht zum aktuell ausgeführten Funktion, so, dass man das <code>Function</code> Objekt über den Namen referenzierten muss, auch im Funktionskörper.</p>
+
+<h2 id="Funktionen_definieren">Funktionen definieren</h2>
+
+<p>Es gibt verschiedenen Möglichkeiten Funktionen zu definieren:</p>
+
+<h3 id="Die_Funktionsdeklaration_function_Statement">Die Funktionsdeklaration (<code>function</code> Statement)</h3>
+
+<p>Es gibt eine spezielle Syntax für das Deklarieren von Funktionen (siehe <a href="/de/docs/Web/JavaScript/Reference/Statements/function">Funktionsstatement</a> für mehr Details):</p>
+
+<pre class="syntaxbox notranslate">function <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
+ <em>statements</em>
+}
+</pre>
+
+<dl>
+ <dt><code>name</code></dt>
+ <dd>Der Funktionsname.</dd>
+</dl>
+
+<dl>
+ <dt><code>param</code></dt>
+ <dd>Der Name eines Arguments, welches der Funktion übergeben wird. Eine Funktion kann bis zu 255 Argumente haben.</dd>
+</dl>
+
+<dl>
+ <dt><code>statements</code></dt>
+ <dd>Die Statements, welche den Funktionskörper der Funktion bilden.</dd>
+</dl>
+
+<h3 id="Der_Funktionsausdruck_function_Ausdruck">Der Funktionsausdruck (<code>function</code> Ausdruck)</h3>
+
+<p>Ein Funktionsausdruck ist ähnlich wie eine Funktionsdeklaration und hat die selbe Syntax (siehe <a href="/de/docs/Web/JavaScript/Reference/Operators/function">Funktionsausdruck</a> für Details). Ein Funktionsausdruck ist manchmal ein Teil eines größeren Ausdrucks. Man kann benannte Funktionsausdrücke (in denen der Name des Ausdrucks zum Beispiel im Aufrufstack benutzt wird) oder anonyme Funktionsausdrücke definieren. Funktionsausdrücke werden nicht an den Anfang des Gültigkeitsbereiches verschoben (<em>hoisted</em>), was bedeutet, dass sie nicht vor der Definition im Code benutzt werden können.</p>
+
+<pre class="syntaxbox notranslate">function [<em>name</em>]([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
+ <em>statements</em>
+}
+</pre>
+
+<dl>
+ <dt><code>name</code></dt>
+ <dd>Der Funktionsname. Kann weggelassen werden, wodurch die Funktion eine sogenannte anonyme Funktion ist.</dd>
+</dl>
+
+<dl>
+ <dt><code>param</code></dt>
+ <dd>Der Name eines Arguments, welches der Funktion übergeben wird. Eine Funktion kann bis zu 255 Argumente haben.</dd>
+ <dt><code>statements</code></dt>
+ <dd>Die Statements, welche den Funktionskörper der Funktion bilden.</dd>
+</dl>
+
+<p>Hier ist ein Beispiel für einen <strong>anonymen</strong> Funktionsausdruck (<code>name</code> wird nicht benutzt):</p>
+
+<pre class="brush: js notranslate">var myFunction = function() {
+ statements
+}</pre>
+
+<p>Es ist auch möglich den Namen in der Funktionsdefinition erreichbar zu machen, indem eine <strong>benannter</strong> Funktionsausdruck erstellt wird:</p>
+
+<pre class="brush: js notranslate">var myFunction = function namedFunction(){
+ statements
+}
+</pre>
+
+<p>Ein Vorteil beim Erstellen eines benannten Funktionsausdrucks ist, dass im Fall eines auftretenden Fehlers, der Name der Funktion im Stack Trace enthalten ist, was es einfacher macht den Ursprung des Fehlers zu finden.</p>
+
+<p>Wie gezeigt, beginnen beide Beispiele nicht mit dem <code>function</code> Schlüsselwort. Statements die Funktionen enthalten aber nicht mit <code>function</code> beginnen, sind Funktionsausdrücke.</p>
+
+<p>Wenn eine Funktion nur einmal benutzt wird, wird ein Pattern namens <strong>IIFE (<em>Immediately Invokable Function Expression</em>)</strong> genutzt.</p>
+
+<pre class="brush: js notranslate">(function() {
+ statements
+})();</pre>
+
+<p>IIFE sind Funktionsausdrücke, die direkt nach dem Definieren ausgeführt werden.</p>
+
+<h3 id="Die_Generatorfunktionendeklaration_function*_Statement">Die Generatorfunktionendeklaration (<code>function*</code> Statement)</h3>
+
+<p>Es gibt eine spezielle Syntax für die Deklaration von Generatorfunktionen (siehe {{jsxref('Statements/function*', 'function* Statement')}} für Details):</p>
+
+<pre class="syntaxbox notranslate">function* <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
+ <em>statements</em>
+}
+</pre>
+
+<dl>
+ <dt><code>name</code></dt>
+ <dd>Der Funktionsname.</dd>
+</dl>
+
+<dl>
+ <dt><code>param</code></dt>
+ <dd>Der Name eines Arguments, welches der Funktion übergeben wird. Eine Funktion kann bis zu 255 Argumente haben.</dd>
+</dl>
+
+<dl>
+ <dt><code>statements</code></dt>
+ <dd>Die Statements, welche den Funktionskörper der Funktion bilden.</dd>
+</dl>
+
+<h3 id="Der_Generatorfunktionsausdruck_function*_Ausdruck">Der Generatorfunktionsausdruck (<code>function*</code> Ausdruck)</h3>
+
+<p>Ein Generatorfunktionsausdruck ist ähnlich wie eine Generatorfunktionsdeklaration und hat die selbe Syntax (siehe {{jsxref('Operators/function*', 'function* expression')}} für Details):</p>
+
+<pre class="syntaxbox notranslate">function* [<em>name</em>]([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
+ <em>statements</em>
+}
+</pre>
+
+<dl>
+ <dt><code>name</code></dt>
+ <dd>Der Funktionsname. Kann weggelassen werden, wodurch die Funktion eine sogenannte anonyme Funktion ist.</dd>
+</dl>
+
+<dl>
+ <dt><code>param</code></dt>
+ <dd>Der Name eines Arguments, welches der Funktion übergeben wird. Eine Funktion kann bis zu 255 Argumente haben.</dd>
+ <dt><code>statements</code></dt>
+ <dd>Die Statements, welche den Funktionskörper der Funktion bilden.</dd>
+</dl>
+
+<h3 id="Der_Pfeilfunktionsausdruck_>">Der Pfeilfunktionsausdruck (=&gt;)</h3>
+
+<p>Eine Pfeilfunktionsausdruck hat eine kürzere Syntax und der <code>this</code> Wert ist lexikalisch gebunden (siehe <a href="/de/docs/Web/JavaScript/Reference/Functions/Pfeilfunktionen">Pfeilfunktionen</a> für Details):</p>
+
+<pre class="syntaxbox notranslate">([param[, param]]) =&gt; {
+ statements
+}
+
+param =&gt; expression
+</pre>
+
+<dl>
+ <dt><code>param</code></dt>
+ <dd>Der Name eines Arguments. Keine Argumente müssen mit <code>()</code> angegeben werden. Für nur ein Argument sind die Klammern nicht notwendig (z. B. <code>foo =&gt; 1</code>).</dd>
+ <dt><code>statements or expression</code></dt>
+ <dd>Mehrere Statements müssen in Klammern geschrieben werden. Ein einziger Ausdruck benötigt keine Klammern. Dieser Ausdruck ist implizit der Rückgabewert der Funktion.</dd>
+</dl>
+
+<h3 id="Der_Function_Konstruktor">Der <code>Function</code> Konstruktor</h3>
+
+<div class="note">
+<p><strong>Hinweis:</strong> Der Einsatz des <code>Function</code> Konstruktors, um eine Funktion zu erstellen wird nicht empfohlen, weil der Funktionskörper als String übergeben wird, welcher von einigen JS Engines nicht optimiert werden kann und zu Problemen führen kann.</p>
+</div>
+
+<p>Wie alle anderen Objekte, können {{jsxref("Function")}} Objekte mit dem <code>new</code> Operator erstellt werden:</p>
+
+<pre class="syntaxbox notranslate">new Function (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>functionBody</em>)
+</pre>
+
+<dl>
+ <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
+ <dd>Null oder mehr Namen, welche von der Funktion als formale Parameter benutzt werden. Jeder muss ein valider JavaScript Bezeichner sein.</dd>
+</dl>
+
+<dl>
+ <dt><code>functionBody</code></dt>
+ <dd>Ein String, der die JavaScript Statements enthält, die den Funktionskörper formen.</dd>
+</dl>
+
+<p>Das Ausführen des <code>Function</code> Konstruktors als Funktion (ohne den Einsatz des <code>new</code> Operators) hat den selben Effekt wie das Aufrufen als Konstruktor.</p>
+
+<h3 id="Der_GeneratorFunction_Konstruktor">Der <code>GeneratorFunction</code> Konstruktor</h3>
+
+<div class="note">
+<p><strong>Hinweis:</strong> <code>GeneratorFunction</code> ist kein globales Objekt, kann aber von Generatorfunktionsinstanzen erhalten werden (siehe {{jsxref("GeneratorFunction")}} für mehr Details).</p>
+</div>
+
+<div class="note">
+<p><strong>Hinweis:</strong> Der Einsatz des <code>GeneratorFunction</code> Konstruktors, um eine Funktion zu erstellen wird nicht empfohlen, weil der Funktionskörper als String übergeben wird, welcher von einigen JS Engines nicht optimiert werden kann und zu Problemen führen kann.</p>
+</div>
+
+<p>Wie alle anderen Objekte, können {{jsxref("GeneratorFunction")}} Objekte mit dem <code>new</code> Operator erstellt werden:</p>
+
+<pre class="syntaxbox notranslate">new GeneratorFunction (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>functionBody</em>)
+</pre>
+
+<dl>
+ <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
+ <dd>Null oder mehr Namen, welche von der Funktion als formale Parameter benutzt werden. Jeder muss ein valider JavaScript Bezeichner sein oder eine Liste solcher Strings mit Komma getrennt. Zum Beispiel "<code>x</code>", "<code>theValue</code>", or "<code>a,b</code>".</dd>
+</dl>
+
+<dl>
+ <dt><code>functionBody</code></dt>
+ <dd>Ein String, der die JavaScript Statements enthält, die den Funktionskörper formen.</dd>
+</dl>
+
+<p>Das Ausführen des <code>GeneratorFunction </code>Konstruktors als Funktion (ohne den Einsatz des <code>new</code> Operators) hat den selben Effekt wie das Aufrufen als Konstruktor.</p>
+
+<h2 id="Funktionsparameter">Funktionsparameter</h2>
+
+<h3 id="Standardparameter">Standardparameter</h3>
+
+<p>Standard Funktionsparameter erlauben es formale Parameter mit einem Standardwert zu initialisieren, wenn kein Wert oder <code>undefined</code> übergeben wird. Für mehr Details siehe <a href="/de/docs/Web/JavaScript/Reference/Functions/Default_parameters">Standardparameter</a>.</p>
+
+<h3 id="Rest_Parameter">Rest Parameter</h3>
+
+<p>Die Rest Parameter Syntax erlaubt die Repräsentation von beliebig fielen Argumenten als ein Array. Für mehr Details siehe <a href="/de/docs/Web/JavaScript/Reference/Functions/rest_parameters">Rest Parameter</a>.</p>
+
+<h2 id="Das_arguments_Objekt">Das <code>arguments</code> Objekt</h2>
+
+<p>Man kann die Funktionsargumente in einer Funktion referenzieren, indem das <code>arguments</code> Objekt benutzt wird. Siehe <a href="/de/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a>.</p>
+
+<ul>
+ <li><code><a href="/de/docs/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a></code>: Ein arrayähnliches Objekt, welches die übergebenen Argumente in der aktuell ausgeführten Funktion enthält.</li>
+ <li><code><a href="/de/docs/JavaScript/Reference/Functions_and_function_scope/arguments/callee">arguments.callee</a></code> {{Deprecated_inline}}: Die aktuell ausgeführte Funktion.</li>
+ <li><code><a href="/de/docs/JavaScript/Reference/Functions_and_function_scope/arguments/caller">arguments.caller</a></code> {{Obsolete_inline}} : Die Funktion, die die aktuell ausgeführte Funktion aufgerufen hat.</li>
+ <li><code><a href="/de/docs/JavaScript/Reference/Functions_and_function_scope/arguments/length">arguments.length</a></code>: Die Anzahl der Argumente, die der Funktion übergeben wurden.</li>
+</ul>
+
+<h2 id="Methodenfunktionen_definieren">Methodenfunktionen definieren</h2>
+
+<h3 id="Getter_und_Setter_Funktionen">Getter und Setter Funktionen</h3>
+
+<p>Man kann Getter (Zugriffsmethoden) und Setter (Änderungsmethoden) bei jedem Standardobjekt oder benutzerdefinierten Objekt, welches das Hinzufügen von neuen Eigenschaften unterstützt. Die Syntax für das Definieren von Gettern und Settern beim Einsatz der Objektliteralsyntax.</p>
+
+<dl>
+ <dt><a href="/de/docs/Web/JavaScript/Reference/Functions/get">get</a></dt>
+ <dd>
+ <p>Bindet eine Objekteigenschaft an eine Funktion, welche aufgerufen wird, wenn der Wert der Eigenschaft abgefragt wird.</p>
+ </dd>
+ <dt><a href="/de/docs/Web/JavaScript/Reference/Functions/set">set</a></dt>
+ <dd>Bindet eine Objekteigenschaft an eine Funktion, welche aufgerufen wird, wenn der Wert der Eigenschaft geändert wird.</dd>
+</dl>
+
+<h3 id="Methodendefinitionssyntax">Methodendefinitionssyntax</h3>
+
+<p>Angefangen mit ECMAScript 2015 kann man eigene Methoden in einer kürzeren Syntax, ähnlich wie Getter und Setter, definieren. Siehe <a href="/de/docs/Web/JavaScript/Reference/Functions/Method_definitions">Methodendefinition</a> für mehr Details.</p>
+
+<pre class="brush: js notranslate">var obj = {
+ foo() {},
+ bar() {}
+};</pre>
+
+<h2 id="Konstruktor_vs._Deklaration_vs._Ausdruck">Konstruktor vs. Deklaration vs. Ausdruck</h2>
+
+<p>Das folgende wird verglichen:</p>
+
+<p>Eine Funktion, die mit dem <code>Function</code> Konstruktor definiert wird und der Variablen <code>multiply</code> zugewiesen wird:</p>
+
+<pre class="brush: js notranslate">var multiply = new Function('x', 'y', 'return x * y');</pre>
+
+<p>Eine Funktionsdeklaration mit dem Namen <code>multiply</code>:</p>
+
+<pre class="brush: js notranslate">function multiply(x, y) {
+ return x * y;
+} // there is no semicolon here
+</pre>
+
+<p>Ein Funktionsausdruck einer anonymen Funktion, die der Variablen <code>multiply</code> zugewiesen wird:</p>
+
+<pre class="brush: js notranslate">var multiply = function(x, y) {
+ return x * y;
+};
+</pre>
+
+<p>Ein Funktionsausdruck der Funktion <code>func_name</code>, die der Variablen <code>multiply</code> zugewiesen wird:</p>
+
+<pre class="brush: js notranslate">var multiply = function func_name(x, y) {
+ return x * y;
+};
+</pre>
+
+<h3 id="Unterschiede">Unterschiede</h3>
+
+<p>Alle machen annähernd die selben Dinge, jedoch mit kleinen subtilen Unterschieden:</p>
+
+<p>Es gibt einen Unterschied zwischen dem Funktionsnamen und der Variable, der die Funktion zugewiesen wird. Der Funktionsnamen kann nicht geändert werden, während die Variable, die mit der Funktion zugewiesen ist, überschrieben werden kann. Der Funktionsname kann nur innerhalb des Funktionskörpers benutzt werden. Der Versuch diesen außerhalb des Funktionskörpers zu benutzen resultiert in einem Fehler (oder <code>undefined</code>, wenn der Funktionsname vorher mit einem <code>var</code> Statement deklariert wurde). Zum Beispiel:</p>
+
+<pre class="brush: js notranslate">var y = function x() {};
+alert(x); // Führt zu einem Error
+</pre>
+
+<p>Der Funktionsname taucht auch auf, wenn die Funktion mit der <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Function/toString">toString Methode</a> serialisiert wird.</p>
+
+<p>Auf der anderen Seite ist die Variable, der die Funktion zugewiesen ist, nur durch ihren Gültigkeitsbereich begrenzt, der garantiert den Geltungsbereich einschließt, in dem die Funktion deklariert ist.</p>
+
+<p>Wie das 4. Beispiel zeigt, kann sich der Funktionsname von dem Namen der Variablen, der die Funktion zugewiesen ist, unterscheiden. Diese sind nicht voneinander abhängig. Eine Funktionsdeklaration erstellt ebenfalls eine Variable mit dem selben Namen wie die Funktion. Im Gegensatz zu den durch Funktionsausdrücke definierten Funktionen können Funktionen, die durch Funktionsdeklarationen definiert sind, über ihren Namen in dem Bereich aufgerufen werden, in dem sie definiert wurden:</p>
+
+<p>Eine Funktionsdefinition mit '<code>new Function'</code> hat keinen Funktionsnamen. In der <a href="/de/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> JavaScript Engine haben solche Funktionen in serialisierter Form immer den Namen "anonymous". Zum Beispiel gibt <code>alert(new Function())</code> folgendes aus:</p>
+
+<pre class="brush: js notranslate">function anonymous() {
+}
+</pre>
+
+<p>Weil die Funktion aktuell keinen Namen hat, ist <code>anonymous</code> keine Variable, die in der Funktion erreicht werden kann. Zum Beispiel führt folgendes zu einem Fehler:</p>
+
+<pre class="brush: js notranslate">var foo = new Function("alert(anonymous);");
+foo();
+</pre>
+
+<p>Anders als Funktionsdefinitionen mit Funktionsausdrücken oder dem <code>Function</code> Konstruktor, kann eine Funktionsdefinition mit Funktionsdeklaration genutzt werden, bevor bevor sie deklariert wird. Zum Beispiel:</p>
+
+<pre class="brush: js notranslate">foo(); // alerts FOO!
+function foo() {
+ alert('FOO!');
+}
+</pre>
+
+<p>Eine Funktionsdefinition mit einem Funktionsausdruck oder einer Funktionsdeklaration erbt den aktuellen Gültigkeitsbereich. Das bedeutet, die Funktion bildet eine Closure. Auf der anderen Seite erbt eine Funktion, die mit dem <code>Function</code> Konstruktor definiert wird, keinen anderen Gültigkeitsbereich außer dem globalen (welchen alle Funktionen erben).</p>
+
+<pre class="brush: js notranslate">/*
+ * Declare and initialize a variable 'p' (global)
+ * and a function 'myFunc' (to change the scope) inside which
+ * declare a varible with same name 'p' (current) and
+ * define three functions using three different ways:-
+ * 1. function declaration
+ * 2. function expression
+ * 3. function constructor
+ * each of which will log 'p'
+ */
+var p = 5;
+function myFunc() {
+ var p = 9;
+
+ function decl() {
+ console.log(p);
+ }
+ var expr = function() {
+ console.log(p);
+ };
+ var cons = new Function('\tconsole.log(p);');
+
+ decl();
+ expr();
+ cons();
+}
+myFunc();
+
+/*
+ * Logs:-
+ * 9 - for 'decl' by function declaration (current scope)
+ * 9 - for 'expr' by function expression (current scope)
+ * 5 - for 'cons' by Function constructor (global scope)
+ */
+</pre>
+
+<p>Funktionsdefinitionen als Funktionsausdrücke und Funktionsdeklarationen werden nur einmal übersetzt, während das bei <code>Function</code> Konstruktoren nicht so ist. Das bedeutet, dass der Funktionskörper, der dem <code>Function</code> Konstruktor übergeben wird, mit jedem Aufruf des Konstruktors erneut übersetzt wird. Weil ein Funktionsausdruck jedes mal eine Closure erstellt und der Funktionskörper aber nicht erneut übersetzt wird, sind Funktionsausdrücke um einiges schneller als "<code>new Function(...)</code>". Deshalb sollte der <code>Function</code> Konstruktor überall vermieden werden, wo es geht.</p>
+
+<p>Es sollte bemerkt werden, dass immer wenn Funktionsausdrücke und Funktionsdeklarationen verschachtelt in einer Funktion generiert vom <code>Function</code> Konstruktor erstellt werden, sie nicht mehrfach übersetzt werden. Zum Beispiel:</p>
+
+<pre class="brush: js notranslate">var foo = (new Function("var bar = \'FOO!\';\nreturn(function() {\n\talert(bar);\n});"))();
+foo(); // The segment "function() {\n\talert(bar);\n}" of the function body string is not re-parsed.</pre>
+
+<p>Eine Funktionsdeklaration wird sehr einfach (und oft unabsichtlich) in einen Funktionsausdruck geändert. Eine Funktionsdeklaration hört auf eine zu sein, wenn:</p>
+
+<ul>
+ <li>sie ein Teil eines Ausdrucks wird</li>
+ <li>sie kein "source element" einer Funktion oder des Skriptes selbst ist. Ein "source element" ist ein nicht geschachteltes Statement im Skript oder eines Funktionskörpers:</li>
+</ul>
+
+<pre class="brush: js notranslate">var x = 0; // source element
+if (x === 0) { // source element
+ x = 10; // not a source element
+ function boo() {} // not a source element
+}
+function foo() { // source element
+ var y = 20; // source element
+ function bar() {} // source element
+ while (y === 10) { // source element
+ function blah() {} // not a source element
+ y++; // not a source element
+ }
+}
+</pre>
+
+<h3 id="Beispiele">Beispiele</h3>
+
+<pre class="brush: js notranslate">// Funktionsdeklaration
+function foo() {}
+
+// Funktionsausdruck
+(function bar() {})
+
+// Funktionsausdruck
+x = function hello() {}
+
+
+if (x) {
+ // Funktionsausdruck
+ function world() {}
+}
+
+
+// Funktionsdeklaration
+function a() {
+ // Funktionsdeklaration
+ function b() {}
+ if (0) {
+ // Funktionsausdruck
+ function c() {}
+ }
+}
+</pre>
+
+<h2 id="Funktionen_als_Block-Level-Element">Funktionen als Block-Level-Element</h2>
+
+<p>Beginnend mit ES2015 sind Funktionen im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">strict Modus</a> an den Block gebunden. Vor ES2015 waren Funktionen auf Blockebene im strikten Modus verboten.</p>
+
+<pre class="brush: js notranslate">'use strict';
+
+function f() {
+ return 1;
+}
+
+{
+ function f() {
+ return 2;
+ }
+}
+
+f() === 1; // true
+
+// f() === 2 nicht im strict Modus
+</pre>
+
+<h3 id="Block-level_Funktionen_im_nicht-strict_Code">Block-level Funktionen im nicht-strict Code</h3>
+
+<p>Kurz gesagt: nicht machen.</p>
+
+<p>Im nicht strict Code verhalten sich Funktionsdeklarationen innerhalb von Blöcken merkwürdig. Zum Beispiel:</p>
+
+<pre class="brush: js notranslate">if (shouldDefineZero) {
+ function zero() { // DANGER: compatibility risk
+ console.log("This is zero.");
+ }
+}
+</pre>
+
+<p>ES2015 besagt, dass wenn <code>shouldDefineZero</code> false ist, <code>zero</code> niemals definiert wird, weil der Block nie ausgeführt wird. Jedoch ist das ein neuer Teil des Standards. Historisch war dieser Teil unspezifiziert und einigen Browser definierten <code>zero</code> egal, ob der Block ausgeführt wurde oder nicht.</p>
+
+<p>Im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">strict Modus</a> verhalten sich alle Browser, die ES2015 unterstützen, gleich. <code>zero</code> wird nur Definiert wenn <code>shouldDefineZero</code> true ist und nur in dem Gültigkeitsbereich des <code>if</code>-Blocks.</p>
+
+<p>Ein sicherer Weg eine Funktion bedingt zu definieren ist es einen Funktionsausdruck einer Variablen zuzuweisen:</p>
+
+<pre class="brush: js notranslate">var zero;
+if (shouldDefineZero) {
+ zero = function() {
+ console.log("This is zero.");
+ };
+}
+</pre>
+
+<h2 id="Beispiele_2">Beispiele</h2>
+
+<h3 id="Zurückgeben_einer_formatierten_Zahl">Zurückgeben einer formatierten Zahl</h3>
+
+<p>Die folgende Funktion gibt einen String zurück, der eine formatierte Zahlenrepräsentation mit führenden Nullen enthält.</p>
+
+<pre class="brush: js notranslate">// This function returns a string padded with leading zeros
+function padZeros(num, totalLen) {
+ var numStr = num.toString(); // Initialize return value as string
+ var numZeros = totalLen - numStr.length; // Calculate no. of zeros
+ for (var i = 1; i &lt;= numZeros; i++) {
+ numStr = "0" + numStr;
+ }
+ return numStr;
+}
+</pre>
+
+<p>Die folgende Statements rufen die padZeros Funktion auf.</p>
+
+<pre class="brush: js notranslate">var result;
+result = padZeros(42,4); // returns "0042"
+result = padZeros(42,2); // returns "42"
+result = padZeros(5,4); // returns "0005"
+</pre>
+
+<h3 id="Prüfen_ob_eine_Funktoin_vorhanden_ist">Prüfen, ob eine Funktoin vorhanden ist</h3>
+
+<p>Man kann prüfen, ob eine Funktion existiert, indem man den <code>typeof</code> Operator benutzt wird. Im folgenden Beispiel wird getestet, ob das Objekt <code>window</code> eine Eigenschaft mit dem Namen <code>noFunc</code> hat, die eine Funktion ist. Wenn das so ist, wird sie benutzt, andernfalls wird etwas anderes gemacht.</p>
+
+<pre class="brush: js notranslate"> if ('function' === typeof window.noFunc) {
+ // use noFunc()
+ } else {
+ // do something else
+ }
+</pre>
+
+<p>Zu beachten ist, dass im <code>if</code> Test eine Referenz zu <code>noFunc</code> benutzt wird — es stehen keine Klammern <code>()</code> nach dem Funktionsnamen, so dass die Funktion nicht aufgerufen wird.</p>
+
+<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.0</td>
+ </tr>
+ <tr>
+ <td>{{SpecName('ES5.1', '#sec-13', 'Function Definition')}}</td>
+ <td>{{Spec2('ES5.1')}}</td>
+ <td></td>
+ </tr>
+ <tr>
+ <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td>
+ <td>{{Spec2('ES6')}}</td>
+ <td>Neu: Pfeilfunktionen, Generatorfunktionen, Standardparameter, Rest Parameter.</td>
+ </tr>
+ <tr>
+ <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}</td>
+ <td>{{Spec2('ESDraft')}}</td>
+ <td></td>
+ </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.functions")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Statements/function", "Funktionsstatement")}}</li>
+ <li>{{jsxref("Operators/function", "Funktionsausdruck")}}</li>
+ <li>{{jsxref("Statements/function*", "function* Statement")}}</li>
+ <li>{{jsxref("Operators/function*", "function* Ausdruck")}}</li>
+ <li>{{jsxref("Function")}}</li>
+ <li>{{jsxref("GeneratorFunction")}}</li>
+ <li>{{jsxref("Functions/Arrow_functions", "Pfeilfunktionen")}}</li>
+ <li>{{jsxref("Functions/Default_parameters", "Standardparameter")}}</li>
+ <li>{{jsxref("Functions/rest_parameters", "Rest Parameter")}}</li>
+ <li>{{jsxref("Functions/arguments", "Arguments Objekt")}}</li>
+ <li>{{jsxref("Functions/get", "Getter")}}</li>
+ <li>{{jsxref("Functions/set", "Setter")}}</li>
+ <li>{{jsxref("Functions/Method_definitions", "Methodendefinitionen")}}</li>
+ <li><a href="/de/docs/Web/JavaScript/Reference/Functions_and_function_scope">Funktionen und Funktionsgültigkeitsbereiche</a></li>
+</ul>
diff --git a/files/de/web/javascript/reference/functions/methoden_definitionen/index.html b/files/de/web/javascript/reference/functions/methoden_definitionen/index.html
new file mode 100644
index 0000000000..bf4d432627
--- /dev/null
+++ b/files/de/web/javascript/reference/functions/methoden_definitionen/index.html
@@ -0,0 +1,230 @@
+---
+title: Methoden Definitionen
+slug: Web/JavaScript/Reference/Functions/Methoden_Definitionen
+tags:
+ - ECMAScript 2015
+ - Funktionen
+ - JavaScript
+ - Objekte
+ - Syntax
+translation_of: Web/JavaScript/Reference/Functions/Method_definitions
+---
+<div>{{JsSidebar("Functions")}}</div>
+
+<p>Beginnend mit ECMAScript 2015 wurde eine kürzere Syntax für Methodendefinitionen in Objekt Initialisierungen eingeführt. Es ist eine Abkürzung für die Zuweisung einer Funktion an einen Methodennamen.</p>
+
+<h2 id="Syntax" name="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">var obj = {
+ <var>property</var>( <var>parameters…</var> ) {},
+ *<var>generator</var>( <var>parameters…</var> ) {},
+// also with computed keys:
+ [property]( <var>parameters…</var> ) {},
+ *[generator]( <var>parameters…</var> ) {},
+// compare ES5 getter/setter syntax:
+ get <var>property</var>() {},
+ set <var>property</var>(<var>value</var>) {}
+};
+</pre>
+
+<h2 id="Description" name="Description">Beschreibung</h2>
+
+<p>Die Syntax der Kurzschreibweise ähnelt der in ECMAScript 2015 eingeführten Syntax der <a href="/de/docs/Web/JavaScript/Reference/Functions/get">getter</a> und <a href="/de/docs/Web/JavaScript/Reference/Functions/set">setter</a>.</p>
+
+<p>Gegeben sei der folgende Quellcode:</p>
+
+<pre class="brush: js">var obj = {
+ foo: function() {},
+ bar: function() {}
+};</pre>
+
+<p>Jetzt können Sie das abkürzen zu:</p>
+
+<pre class="brush: js">var obj = {
+ foo() {},
+  bar() {}
+};</pre>
+
+<div class="note">
+<p><strong>Hinweis:</strong> Die kurze Syntax benutzt benamte Funktionen statt anonymen Funktionen (wie in ...<code>foo: function() {}</code>...). Benamte Funktionen können sich vom Funktionskörper aus aufrufen (für anonyme Funktionen ist das unmöglich, weil sie keinen Bezeichner haben). Für mehr Details, siehe {{jsxref("Operators/function","function","#Beispiele")}}.</p>
+</div>
+
+<h3 id="Kurze_Generatormethoden">Kurze Generatormethoden</h3>
+
+<p><a href="/de/docs/Web/JavaScript/Reference/Statements/function*">Generatormethoden</a> können mit der kurzen Syntax ebenfalls definiert werden. Zu beachten ist, dass der Stern (*) in der kurzen Syntax nur vor dem Namen der Generatoreigenschaft geschrieben werden kann. <code>* g(){}</code> funktioniert, <code>g *(){}</code> funktioniert nicht.</p>
+
+<pre class="brush: js;highlight[12]">// Using a named property (pre-ES2015)
+var obj2 = {
+ g: function*() {
+ var index = 0;
+ while(true)
+ yield index++;
+ }
+};
+
+// The same object using shorthand syntax
+var obj2 = {
+ * g() {
+ var index = 0;
+ while(true)
+ yield index++;
+ }
+};
+
+var it = obj2.g();
+console.log(it.next().value); // 0
+console.log(it.next().value); // 1</pre>
+
+<h3 id="Methodendefinitionen_die_nicht_konstruiert_werden_können">Methodendefinitionen die nicht konstruiert werden können</h3>
+
+<p>Alle Methodendefinitionen die keine Konstruktoren sind werden einen {{jsxref("TypeError")}} erzeugen,  wenn man versucht sie zu instantieren.</p>
+
+<pre class="brush: js example-bad">var obj = {
+ method() {},
+};
+new obj.method; // TypeError: obj.method is not a constructor
+
+var obj = {
+ * g() {}
+};
+new obj.g; // TypeError: obj.g is not a constructor (changed in ES2016)
+</pre>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Ein_einfacher_Testfall">Ein einfacher Testfall</h3>
+
+<pre class="brush: js;highlight[3]">var obj = {
+ a : "foo",
+ b(){ return this.a; }
+};
+console.log(obj.b()); // "foo"
+</pre>
+
+<h3 id="Berechnete_Eigenschaftsnamen">Berechnete Eigenschaftsnamen</h3>
+
+<p>Die Kurzschreib-Syntax unterstützt auch berechnete Eigenschaftsnamen.</p>
+
+<pre class="brush: js;highlight[4]">var bar = {
+ foo0 : function (){return 0;},
+ foo1(){return 1;},
+ ["foo" + 2](){return 2;},
+};
+
+console.log(bar.foo0()); // 0
+console.log(bar.foo1()); // 1
+console.log(bar.foo2()); // 2</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('ES2015', '#sec-method-definitions', 'Method definitions')}}</td>
+ <td>{{Spec2('ES2015')}}</td>
+ <td>Initiale Definition.</td>
+ </tr>
+ <tr>
+ <td>{{SpecName('ES7', '#sec-method-definitions', 'Method definitions')}}</td>
+ <td>{{Spec2('ES7')}}</td>
+ <td>Geändert, dass Generatormethoden ebenfalls nicht initialisierbar sind und einen Fehler schmeißen, wenn sie mit <code>new</code> eingesetzt werden.</td>
+ </tr>
+ <tr>
+ <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td>
+ <td>{{Spec2('ESDraft')}}</td>
+ <td> </td>
+ </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+ <tr>
+ <th>Feature</th>
+ <th>Chrome</th>
+ <th>Firefox (Gecko)</th>
+ <th>Internet Explorer</th>
+ <th>Opera</th>
+ <th>Safari</th>
+ </tr>
+ <tr>
+ <td>Method definition shorthand</td>
+ <td>{{CompatChrome("39")}}</td>
+ <td>{{CompatGeckoDesktop("34")}}</td>
+ <td>{{CompatNo}}</td>
+ <td>{{CompatOpera("26")}}</td>
+ <td>{{CompatNo}}</td>
+ </tr>
+ <tr>
+ <td>Generator methods are not constructable (ES2016)</td>
+ <td>{{CompatUnknown}}</td>
+ <td>{{CompatGeckoDesktop("43")}}</td>
+ <td>{{CompatUnknown}}</td>
+ <td>{{CompatUnknown}}</td>
+ <td>{{CompatUnknown}}</td>
+ </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+ <tr>
+ <th>Feature</th>
+ <th>Android</th>
+ <th>Chrome for Android</th>
+ <th>Firefox Mobile (Gecko)</th>
+ <th>IE Mobile</th>
+ <th>Opera Mobile</th>
+ <th>Safari Mobile</th>
+ </tr>
+ <tr>
+ <td>Method definition shorthand</td>
+ <td>{{CompatNo}}</td>
+ <td>{{CompatNo}}</td>
+ <td>{{CompatGeckoMobile("34")}}</td>
+ <td>{{CompatNo}}</td>
+ <td>{{CompatNo}}</td>
+ <td>{{CompatNo}}</td>
+ </tr>
+ <tr>
+ <td>Generator methods are not constructable (ES2016)</td>
+ <td>{{CompatUnknown}}</td>
+ <td>{{CompatUnknown}}</td>
+ <td>{{CompatGeckoMobile("43")}}</td>
+ <td>{{CompatUnknown}}</td>
+ <td>{{CompatUnknown}}</td>
+ <td>{{CompatUnknown}}</td>
+ </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">SpiderMonkey spezifische Hinweise</h2>
+
+<ul>
+ <li>Vor SpiderMonkey 38 {{geckoRelease(38)}} waren "<code>get</code>" und "<code>set</code>" nicht valide Namen für Generatormethoden. Das wurde in {{bug(1073809)}} behoben.</li>
+ <li>Vor SpiderMonkey 41 {{geckoRelease(41)}} mussten geschweifte Klammern für Methoden nicht notwendiger weise benutzt werden. Jetzt sind sie vorausgesetzt, um konform zur ES2015 Spezifikation zu sein. Es wird ein {{jsxref("SyntaxError")}} in dieser und späteren Versionen erzeugt ({{bug(1150855)}}).
+ <pre class="brush: js example-bad">var o = {x() 12}; // SyntaxError</pre>
+ </li>
+ <li>Die Restriktion, dass Generatormethoden Konstuktoren sind wurde in SpiderMonkey 41 {{geckoRelease(41)}} implementiert. Dazu siehe auch {{bug(1059908)}} und {{bug(1166950)}}</li>
+</ul>
+
+<h2 id="See_also" name="See_also">See also</h2>
+
+<ul>
+ <li><code><a href="/de/docs/Web/JavaScript/Reference/Functions/get">get</a></code></li>
+ <li><code><a href="/de/docs/Web/JavaScript/Reference/Functions/set">set</a></code></li>
+ <li><a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar">Lexical grammar</a></li>
+</ul>
diff --git a/files/de/web/javascript/reference/functions/pfeilfunktionen/index.html b/files/de/web/javascript/reference/functions/pfeilfunktionen/index.html
new file mode 100644
index 0000000000..a29b5ea3cf
--- /dev/null
+++ b/files/de/web/javascript/reference/functions/pfeilfunktionen/index.html
@@ -0,0 +1,360 @@
+---
+title: Pfeilfunktionen
+slug: Web/JavaScript/Reference/Functions/Pfeilfunktionen
+tags:
+ - ECMAScript 2015
+ - Functions
+ - Intermediate
+ - JavaScript
+ - Reference
+translation_of: Web/JavaScript/Reference/Functions/Arrow_functions
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p>Der <strong>Ausdruck einer Pfeilfunktion</strong> hat eine kürzere Syntax als ein <a href="/de/docs/Web/JavaScript/Reference/Operators/function">Funktionsausdruck</a> und hat kein eigenes <code><a href="/de/docs/Web/JavaScript/Reference/Operators/this">this</a></code>, <a href="/de/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a>, <a href="/de/docs/Web/JavaScript/Reference/Operators/super">super</a>, oder <a href="/de/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a>. Solche Funktionsausdrücke sind am besten für Funktionen, die nicht als Methode genutzt werden, geeignet und können nicht als Konstruktoren verwendet werden.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/functions-arrow.html")}}</div>
+
+<h2 id="Syntax">Syntax</h2>
+
+<h3 id="Basis_Syntax">Basis Syntax</h3>
+
+<pre class="syntaxbox">(param1, param2, …, paramN) =&gt; { statements }
+(param1, param2, …, paramN) =&gt; expression
+// gleich zu: =&gt; { return expression; }
+
+// Klammern sind optional, wenn nur ein Parametername vorhanden ist:
+(singleParam) =&gt; { statements }
+singleParam =&gt; { statements }
+
+// Die Parameterliste für eine parameterlose Funktion muss mit einem Klammernpaar geschrieben werden
+() =&gt; { statements }
+</pre>
+
+<h3 id="Fortgeschrittene_Syntax">Fortgeschrittene Syntax</h3>
+
+<pre class="syntaxbox">// Der Body kann eingeklammert werden, um ein Objektliteral Ausdruck zurück zu geben:
+params =&gt; ({foo: bar})
+
+// <a href="/de/docs/Web/JavaScript/Reference/Functions/rest_parameters">Rest Parameter</a> und <a href="/de/docs/Web/JavaScript/Reference/Functions/Default_parameters">Default Parameter</a> werden unterstützt
+(param1, param2, ...rest) =&gt; { statements }
+(param1 = defaultValue1, param2, …, paramN = defaultValueN) =&gt; {
+statements }
+
+// <a href="/de/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">Destrukturierung</a> in der Parameterliste ist ebenfalls unterstützt
+var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) =&gt; a + b + c;
+f(); // 6
+</pre>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Siehe auch <a href="https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/">"ES6 In Depth: Arrow functions" on hacks.mozilla.org</a>.</p>
+
+<p>Zwei Faktoren haben die Einführung von Pfeilfunktionen beeinflusst: kürzere Funktionen und dass <code>this</code> nicht gebunden ist.</p>
+
+<h3 id="Kürzere_Funktionen">Kürzere Funktionen</h3>
+
+<pre class="brush: js">var elements = [
+ "Hydrogen",
+ "Helium",
+ "Lithium",
+ "Beryllium"
+];
+
+elements.map(function(element) {
+ return element.length
+}); // [8, 6, 7, 9]
+
+elements.map(element =&gt; {
+ return element.length
+}); // [8, 6, 7, 9]
+
+elements.map(({length}) =&gt; length); // [8, 6, 7, 9]</pre>
+
+<h3 id="Keine_Bindung_von_this">Keine Bindung von <code>this</code></h3>
+
+<p>Vor (der Einführung von) Pfeilfunktionen definierte jede Funktion ihren eigenen <code><a href="/de/docs/Web/JavaScript/Reference/Operators/this">this</a></code>-Wert (d.h. ein neues Objekt im Falle eines Konstruktors; in <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a> Funktionsaufrufen nicht definiert; bzw. das kontextuelle Objekt, wenn die Funktion als eine "Objekt-Methode" aufgerufen wurde, usw.). Dies stellte sich innerhalb eines objektorientierten Programmierstils als lästig heraus.</p>
+
+<pre class="brush: js">function Person() {
+ // Der Person() Konstruktor definiert `this` als Instanz von sich selbst.
+ this.age = 0;
+
+ setInterval(function growUp() {
+ // Im nicht Strict Modus, definiert die growUp() Funktion `this`
+ // als das globale Objekt (weil das der Ort ist, an dem growUp() ausgeführt wird),
+ // das sich von dem `this`, welches vom Person() Konstruktor definiert wurde unterscheidet.
+ this.age++;
+ }, 1000);
+}
+
+var p = new Person();</pre>
+
+<p>In ECMAScript 3/5 konnte dies durch Zuweisung des Wertes von <code>this</code> an eine Variable, welche umschlossen werden konnte, behoben werden.</p>
+
+<pre class="brush: js">function Person() {
+ var that = this;
+ that.age = 0;
+
+ setInterval(function growUp() {
+ // Der Rückruf bezieht sich auf jene `that`-Variable,
+ // deren Wert das zu erwartende Objekt ist.
+ that.age++;
+ }, 1000);
+}</pre>
+
+<p>Alternativ könnte eine <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">gebundene Funktion</a> erstellt werden, sodass der passende <code>this</code>-Wert an die <code>growUp()</code>-Funktion übergeben würde.</p>
+
+<p>Eine Pfeilfunktion erstellt keinen eigenen <code>this</code> Kontext, wodurch <code>this</code> die ursprüngliche Bedeutung des umschließenden Kontextes trägt. Somit funktioniert der folgende Code wie erwartet.</p>
+
+<pre class="brush: js">function Person(){
+ this.age = 0;
+
+ setInterval(() =&gt; {
+ this.age++; // |this| bezieht sich entsprechend auf das Person-Objekt
+ }, 1000);
+}
+
+var p = new Person();</pre>
+
+<h4 id="Zusammenhang_mit_dem_Strict_Mode">Zusammenhang mit dem Strict Mode</h4>
+
+<p>Vorausgesetzt, dass <code>this</code> aus dem umschließenden lexikalischen Kontext kommt, werden <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict Mode</a> Regeln bezüglich <code>this</code> einfach ignoriert.</p>
+
+<pre class="brush: js">var f = () =&gt; {'use strict'; return this};
+f() === window; // oder das globale Objekt</pre>
+
+<p>Die restlichen strict mode Regeln verhalten sich normal.</p>
+
+<h4 id="Aufruf_durch_call_oder_apply">Aufruf durch call oder apply</h4>
+
+<p>Da <code>this</code><em> </em>in Pfeilfunktionen nicht gebunden ist, können <code>call()</code><em> </em>oder <code>apply()</code> Methoden nur Argumente übergeben; <code>this</code> wird ignoriert:</p>
+
+<pre class="brush: js">var adder = {
+ base : 1,
+
+ add : function(a) {
+ var f = v =&gt; v + this.base;
+ return f(a);
+ },
+
+ addThruCall: function(a) {
+ var f = v =&gt; v + this.base;
+ var b = {
+ base : 2
+ };
+
+ return f.call(b, a);
+ }
+};
+
+console.log(adder.add(1)); // Dies würde 2 ausgeben
+console.log(adder.addThruCall(1)); // Dies würde nach wie vor 2 ausgeben</pre>
+
+<h3 id="Keine_Bindung_von_Argumenten">Keine Bindung von Argumenten</h3>
+
+<p>Pfeilfunktionen haben kein eigenes <a href="/de/docs/Web/JavaScript/Reference/Functions/arguments"><code>arguments</code> Objekt</a>. Somit ist <code>arguments</code> einfach eine Referenz auf den Namen innerhalb des umschließenden Geltungsbereichs (scope).</p>
+
+<pre class="brush: js">var arguments = [1, 2, 3];
+var arr = () =&gt; arguments[0];
+
+arr(); // 1
+
+function foo(n) {
+ var f = () =&gt; arguments[0] + n; // implizite Argumenten-Bindung von <em>foo</em>
+ return f();
+}
+
+foo(1); // 2</pre>
+
+<p>In den meisten Fällen sind <a href="/de/docs/Web/JavaScript/Reference/Functions/rest_parameters">Rest Parameters</a> eine gute Alternative zum Einsatz des <code>arguments</code> Objektes:</p>
+
+<pre class="brush: js">function foo(n) {
+ var f = (...args) =&gt; args[0] + n;
+ return f(10);
+}
+
+foo(1); // 11</pre>
+
+<h3 id="Pfeilfunktionen_als_Methoden">Pfeilfunktionen als Methoden</h3>
+
+<p>Wie angegeben, sind Ausdrücke von Pfeilfunktionen am besten geeignet für nicht-methodische Funktionen. Man sehe, was geschieht, wenn versucht wird, sie als Methoden zu verwenden.</p>
+
+<pre class="brush: js">'use strict';
+
+var obj = {
+ i: 10,
+ b: () =&gt; console.log(this.i, this),
+ c: function() {
+ console.log( this.i, this)
+ }
+}
+obj.b(); // gibt undefined, Window {...} aus (oder das globale Objekt)
+obj.c(); // gibt 10, Object {...} aus</pre>
+
+<p>Pfeilfunktionen definieren (binden sozusagen) kein eigenes <code>this</code>. Ein anderes Beispiel, das {{jsxref("Object.defineProperty()")}} betrifft:</p>
+
+<pre class="brush: js">'use strict';
+
+var obj = {
+ a: 10
+};
+
+Object.defineProperty(obj, "b", {
+ get: () =&gt; {
+ console.log(this.a, typeof this.a, this);
+ return this.a+10; // stellt das globale Objekt 'Window' dar, 'this.a' gibt daher 'undefined' zurück
+ }
+});
+</pre>
+
+<h3 id="Verwendung_des_new_Operators">Verwendung des <code>new</code> Operators</h3>
+
+<p>Pfeilfunktionen können nicht als Konstruktoren verwendet werden. Sie führen zu einem Fehler, wenn auf ihnen ein <code>new</code> angewendet wird.</p>
+
+<pre class="brush: js">var Foo = () =&gt; {};
+var foo = new Foo(); // TypeError: Foo is not a constructor
+</pre>
+
+<h3 id="Einsatz_der_prototype_Eigenschaft">Einsatz der <code>prototype</code> Eigenschaft</h3>
+
+<p>Pfeilfunktionen haben keine <code>prototype</code> Eigenschaft.</p>
+
+<pre class="brush: js">var Foo = () =&gt; {};
+console.log(Foo.prototype); // undefined
+</pre>
+
+<h3 id="Verwendung_des_Schlüsselwortes_yield">Verwendung des Schlüsselwortes <code>yield</code></h3>
+
+<p>Das <code><a href="/de/docs/Web/JavaScript/Reference/Operators/yield">yield</a></code>-Schlüsselwort sollte im Körper einer Pfeilfunktion nicht verwendet werden (außer wenn dies innerhalb von darin weiter verschachtelten Funktionen erlaubt ist). Als Folge können Pfeilfunktionen nicht als Generatoren verwendet werden.</p>
+
+<h2 id="Funktionskörper">Funktionskörper</h2>
+
+<p>Pfeilfunktionen können entweder einen "knappen" oder einen gewöhnlichen "Blockkörper" haben.</p>
+
+<p>In einem knappen Körper ist lediglich ein Ausdruck nötig und eine implizite Rückgabe wird angehängt. In einem Blockkörper muss eine explizite Rückgabe-Anweisung verwendet werden.</p>
+
+<pre class="brush: js">var func = x =&gt; x * x;
+// knappe Syntax, implizierte Rückgabe
+
+var func = (x, y) =&gt; { return x + y; };
+// mit Blockkörper, explizite Rückgabe wird benötigt
+</pre>
+
+<h2 id="Rückgabe_von_Objekt-Literalen">Rückgabe von Objekt-Literalen</h2>
+
+<p>Man bedenke, dass die Rückgabe von Objekt-Literalen unter Verwendung der knappen Syntax <code>params =&gt; {object:literal}</code> nicht so ausgeführt wird, wie man es erwarten würde:</p>
+
+<pre class="brush: js">var func = () =&gt; { foo: 1 };
+// Der Aufruf von func() gibt undefined zurück!
+
+var func = () =&gt; { foo: function() {} };
+// SyntaxError: function-Anweisung erfordert einen Namen</pre>
+
+<p>Der Grund dafür ist, dass der Code in geschweiften Klammern ({}) als eine Sequenz von Anweisungen übersetzt wird (d.h. foo wird als Bezeichner behandelt und nicht als Schlüssel eines Objekt-Literals).</p>
+
+<p>Man bedenke, das Objekt-Literal in Klammern zu setzen:</p>
+
+<pre class="brush: js">var func = () =&gt; ({ foo: 1 });</pre>
+
+<h2 id="Zeilenumbruch">Zeilenumbruch</h2>
+
+<p>Pfeilfunktionen können keinen Zeilenumbruch zwischen Parametern und dem Pfeil haben.</p>
+
+<pre class="brush: js">var func = ()
+ =&gt; 1;
+// SyntaxError: Ausdruck erwartet, '=&gt;' erhalten</pre>
+
+<h2 id="Übersetzungsreihenfolge">Übersetzungsreihenfolge</h2>
+
+<p>Der Pfeil innerhalb einer Pfeilfunktion ist kein Operator. Allerdings haben Pfeilfunktionen im Vergleich zu gewöhnlichen Funktionen besondere Übersetzungsregeln, welche mit der Priorität von Operatoren (<a href="/de/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">operator precedence</a>) anders interagieren.</p>
+
+<pre class="brush: js">let callback;
+
+callback = callback || function() {}; // ok
+
+callback = callback || () =&gt; {};
+// SyntaxError: invalid arrow-function arguments
+
+callback = callback || (() =&gt; {}); // ok
+</pre>
+
+<h2 id="Weitere_Beispiele">Weitere Beispiele</h2>
+
+<pre class="brush: js">// Eine leere Pfeilfunktion gibt undefined zurück
+let empty = () =&gt; {};
+
+(() =&gt; "foobar")()
+// Gibt "foobar" zurück
+// (Das ist eine Immediately Invoked Function Expression
+// siehe IIFE im Glossar
+
+var simple = a =&gt; a &gt; 15 ? 15 : a;
+simple(16); // 15
+simple(10); // 10
+
+let max = (a, b) =&gt; a &gt; b ? a : b;
+
+// Einfaches filtering, mapping, ... von Arrays
+
+var arr = [5, 6, 13, 0, 1, 18, 23];
+
+var sum = arr.reduce((a, b) =&gt; a + b);
+// 66
+
+var even = arr.filter(v =&gt; v % 2 == 0);
+// [6, 0, 18]
+
+var double = arr.map(v =&gt; v * 2);
+// [10, 12, 26, 0, 2, 36, 46]
+
+// Weitere knappe Zusicherungsketten (promise chains)
+promise.then(a =&gt; {
+ // ...
+}).then(b =&gt; {
+ // ...
+});
+
+// Parameterlose Pfeilfunktionen, welche visuell einfacher zu verstehen sind
+setTimeout( _ =&gt; {
+ console.log("I happen sooner");
+ setTimeout( _ =&gt; {
+ // deeper code
+ console.log("I happen later");
+ }, 1);
+}, 1);</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('ES2015', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}</td>
+ <td>{{Spec2('ES2015')}}</td>
+ <td>Initiale Definition.</td>
+ </tr>
+ <tr>
+ <td>{{SpecName('ESDraft', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}</td>
+ <td>{{Spec2('ESDraft')}}</td>
+ <td> </td>
+ </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.functions.arrow_functions")}}</p>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li><a href="https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/">"ES6 In Depth: Arrow functions" on hacks.mozilla.org</a></li>
+</ul>
diff --git a/files/de/web/javascript/reference/functions/rest_parameter/index.html b/files/de/web/javascript/reference/functions/rest_parameter/index.html
new file mode 100644
index 0000000000..a529c7b1d6
--- /dev/null
+++ b/files/de/web/javascript/reference/functions/rest_parameter/index.html
@@ -0,0 +1,167 @@
+---
+title: Rest Parameter
+slug: Web/JavaScript/Reference/Functions/rest_parameter
+tags:
+ - Functions
+ - JavaScript
+ - Rest
+ - Rest Parameter
+translation_of: Web/JavaScript/Reference/Functions/rest_parameters
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p>Mit der <strong>Rest Parameter</strong> Syntax kann man beliebig viele Parameter als Array empfangen.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/functions-restparameters.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="brush: js">function f(a, b, ...restArgs) {
+ // ...
+}
+</pre>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Wenn vor dem letzten Parameter einer Funktion <code>...</code> steht wird aus diesem Parameter ein Array von <code>0</code> (inklusiv) bis zu <code>restArgs.length</code> (exklusiv), welches weitere der Funktion übergebene Parameter enthält.</p>
+
+<p>Im oberen Beispiel enthält das <code>restArgs</code> alle weiteren Argumente außer die ersten beiden, da diese bereits von den Variablen <code>a</code> und <code>b</code> erfasst werden.</p>
+
+<h3 id="Unterschiede_zwischen_Rest_Parametern_und_dem_arguments_Objekt">Unterschiede zwischen Rest Parametern und dem <code>arguments</code> Objekt</h3>
+
+<p>Es gibt drei Hauptunterschiede zwischen Rest Parametern und dem <a href="/de/docs/Web/JavaScript/Reference/Functions/arguments" title="arguments"><code>arguments</code></a> Objekt:</p>
+
+<ul>
+ <li>Rest Parameter sind nur die jenigen, die zu einem Namen gehören (z. B. in Funktionsausdrücken formal definierte Parameter), während das <code>arguments</code> Objekt alle übergebenen Argumente einer Funktion enthällt.</li>
+ <li>Das <code>arguments</code> Objekt ist kein echtes Array, während Rest Parameter eine <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array" title="Array"><code>Array</code></a> sind, was bedeutet, dass Methoden wie <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array/sort" title="Array sort method"><code>sort</code></a>, <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array/map" title="Array map method"><code>map</code></a>, <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach" title="Array forEach method"><code>forEach</code></a> oder <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array/pop" title="Array pop method"><code>pop</code></a> direkt angewendet werden können.</li>
+ <li>Das <code>arguments</code> Objekt hat zusätzliche, spezielle Funktionalität (wie die <code>callee</code> Eigenschaft).</li>
+</ul>
+
+<h3 id="Von_arguments_zu_einem_Array">Von <code>arguments</code> zu einem Array</h3>
+
+<p>Rest Parameter wurden eingeführt, um Standardcode zu reduzieren, welche beim Einsatz von <code>arguments</code> anfällt</p>
+
+<pre class="brush: js">// Before rest parameters, the following could be found:
+function f(a, b) {
+ var args = Array.prototype.slice.call(arguments, f.length);
+
+ // …
+}
+
+// to be equivalent of
+
+function f(a, b, ...args) {
+
+}
+</pre>
+
+<h3 id="Destrukturierte_Rest_Parameter">Destrukturierte Rest Parameter</h3>
+
+<p>Rest Parameter können destrukturiert werden, was bedeutet, dass sie in einzelne Variablen entpackt werden können. Siehe <a href="/de/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destrukturierende Zuweisung</a>.</p>
+
+<pre class="brush: js">function f(...[a, b, c]) {
+ return a + b + c;
+}
+
+f(1) // NaN (b and c are undefined)
+f(1, 2, 3) // 6
+f(1, 2, 3, 4) // 6 (the fourth parameter is not destructured)</pre>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<p>Weil <code>theArgs</code> ein Array ist, ist die Anzahl der Argumente mit der <code>length</code> Eigenschaft gegeben:</p>
+
+<pre class="brush: js">function fun1(...theArgs) {
+ console.log(theArgs.length);
+}
+
+fun1(); // 0
+fun1(5); // 1
+fun1(5, 6, 7); // 3
+</pre>
+
+<p>Im nächsten Beispiel wird ein Rest Parameter eingesetzt, um alle Argumente außer dem ersten in einem Array zu sammeln. Jedes wird dann mit dem ersten Argument multipliziert und als Array zurückgegeben:</p>
+
+<pre class="brush: js">function multiply(multiplier, ...theArgs) {
+ return theArgs.map(function(element) {
+ return multiplier * element;
+ });
+}
+
+var arr = multiply(2, 1, 2, 3);
+console.log(arr); // [2, 4, 6]
+</pre>
+
+<p>Das folgende Beispiel zeigt, dass <code>Array</code> Methoden auf Rest Parameter jedoch nicht auf <code>arguments</code> Objekten eingesetzt werden können:</p>
+
+<pre class="brush: js">function sortRestArgs(...theArgs) {
+ var sortedArgs = theArgs.sort();
+ return sortedArgs;
+}
+
+console.log(sortRestArgs(5, 3, 7, 1)); // shows 1, 3, 5, 7
+
+function sortArguments() {
+ var sortedArgs = arguments.sort();
+ return sortedArgs; // this will never happen
+}
+
+// throws a TypeError: arguments.sort is not a function
+console.log(sortArguments(5, 3, 7, 1));
+</pre>
+
+<p>Um <code>Array</code> Methoden auf einem <code>arguments</code> Objekt zu benutzen, muss dieses in ein echtes Array konvertiert werden.</p>
+
+<pre class="brush: js">function sortArguments() {
+ var args = Array.from(arguments);
+ var sortedArgs = args.sort();
+ return sortedArgs;
+}
+console.log(sortArguments(5, 3, 7, 1)); // 1, 3, 5, 7
+</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-function-definitions', 'Function Definitions')}}</td>
+ <td>{{Spec2('ES6')}}</td>
+ <td>Initiale Definition</td>
+ </tr>
+ <tr>
+ <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function Definitions')}}</td>
+ <td>{{Spec2('ESDraft')}}</td>
+ <td> </td>
+ </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.functions.rest_parameters")}}</p>
+</div>
+</div>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Spread_operator" title="spread operator">Spread Syntax</a> (auch ‘<code>...</code>’)</li>
+ <li><a href="/de/docs/Web/JavaScript/Reference/Functions/arguments" title="arguments">Arguments Objekt</a></li>
+ <li><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array" title="Array">Array</a></li>
+ <li><a href="/de/docs/Web/JavaScript/Reference/Functions" title="Functions and function scope">Functions</a></li>
+ <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:rest_parameters">Original Vorschlag von ecmascript.org</a></li>
+ <li><a class="external" href="http://javascriptweblog.wordpress.com/2011/01/18/javascripts-arguments-object-and-beyond/">JavaScript arguments object and beyond</a></li>
+ <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">Destrukturierte Zuweisungen</a></li>
+</ul>
diff --git a/files/de/web/javascript/reference/functions/set/index.html b/files/de/web/javascript/reference/functions/set/index.html
new file mode 100644
index 0000000000..7b0e5fcd83
--- /dev/null
+++ b/files/de/web/javascript/reference/functions/set/index.html
@@ -0,0 +1,149 @@
+---
+title: Setter
+slug: Web/JavaScript/Reference/Functions/set
+tags:
+ - ECMAScript 5
+ - Functions
+ - JavaScript
+translation_of: Web/JavaScript/Reference/Functions/set
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p>Die <strong><code>set</code></strong> Syntax bindet eine Objekteigenschaft an eine Funktion welche aufgerufen wird, wenn die Eigenschaft neu beschrieben wird.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/functions-setter.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">{set <em>prop</em>(<em>val</em>) { . . . }}
+{set [expression](<em>val</em>) { . . . }}</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>Der Name der Eigenschaft, die an die gegebene Funktion gebunden wird.</dd>
+</dl>
+
+<dl>
+ <dt><code>val</code></dt>
+ <dd>Ein Alias für die Variable, die den Wert enthält, der der Eigenschaft <code>prop</code> zugewiesen wird.</dd>
+ <dt>expression</dt>
+ <dd>Beginnend mit ECMAScript 2015, kann auch ein Ausdruck für einen berechneten Eigenschaftsnamen genutzt werden, der an die Funktion gebunden wird.</dd>
+</dl>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>In JavaScript kann ein <em>Setter</em> benutzt werden, um eine Funktion aufzurufen, wenn eine Eigenschaft geändert werden soll. Setter werden oft in Verbindung mit Gettern als Pseudoeigenschaft benutzt. Es ist nicht möglich gleichzeitig einen Setter auf einer Eigenschaft zu haben, die eine tatsächlichen Wert hält.</p>
+
+<p>Das folgende ist zu beachten, wenn mit der <code>set</code> Syntax gearbeitet wird:</p>
+
+<div>
+<ul>
+ <li>Sie kann ein Bezeichner enthalten, welcher entweder eine Zahl oder ein String ist</li>
+ <li>Sie muss exakt einen Parameter haben (siehe <a class="external" href="http://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/" rel="external nofollow">Incompatible <abbr title="ECMAScript 5th edition">ES5</abbr> change: literal getter and setter functions must now have exactly zero or one arguments</a> für mehr Informationen);</li>
+ <li>Sie darf nicht in einem Objektliteral mit einem anderen <code>set</code> oder einen Dateneintrag mit der gleichen Eigenschaft geben. (<code>{ set x(v) { }, set x(v) { } }</code> und <code>{ x: ..., set x(v) { } }</code> sind verboten)</li>
+</ul>
+</div>
+
+<p>Ein Setter kann mit dem <a href="/de/docs/Web/JavaScript/Reference/Operators/delete" title="en-US/docs/JavaScript/Reference/Operators/Special/delete"><code>delete</code></a> Operator gelöscht werden.</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Definieren_eines_Setters_in_einem_neuen_Objekt_in_der_Objektinitialisierung">Definieren eines Setters in einem neuen Objekt in der Objektinitialisierung</h3>
+
+<p>Das folgende definiert eine Pseudoeigenschaft <code>current</code> im Objekt <code>language</code>, die bei einer Zuweisung einen Wert in das <code>log</code> Array hinzufügt:</p>
+
+<pre class="brush: js">var language = {
+ set current(name) {
+ this.log.push(name);
+ },
+ log: []
+}
+
+language.current = 'EN';
+console.log(language.log); // ['EN']
+
+language.current = 'FA';
+console.log(language.log); // ['EN', 'FA']
+</pre>
+
+<p>Zu beachten ist, dass <code>current</code> nicht definiert ist und der Zugriff auf diese <code>undefined</code> als Ergebnis liefert.</p>
+
+<h3 id="Löschen_eines_Setter_mit_dem_delete_Operator">Löschen eines Setter mit dem <code>delete</code> Operator</h3>
+
+<p>Wenn ein Setter gelöscht werden soll, muss man einfach <code><a href="/de/docs/Web/JavaScript/Reference/Operators/delete">delete</a></code> benutzen:</p>
+
+<pre class="brush: js">delete o.current;
+</pre>
+
+<h3 id="Definieren_eines_Setters_auf_einem_existierenden_Objekts_mit_defineProperty">Definieren eines Setters auf einem existierenden Objekts mit <code>defineProperty</code></h3>
+
+<p>Um einen Setter später zu einem existierenden Objekt hinzuzufügen, benutzt man {{jsxref("Object.defineProperty()")}}.</p>
+
+<pre class="brush: js">var o = {a: 0};
+
+Object.defineProperty(o, 'b', { set: function(x) { this.a = x / 2; } });
+
+o.b = 10; // Runs the setter, which assigns 10 / 2 (5) to the 'a' property
+console.log(o.a) // 5</pre>
+
+<h3 id="Einsatz_eines_berechneten_Eigenschaftsnamen">Einsatz eines berechneten Eigenschaftsnamen</h3>
+
+<pre class="brush: js">var expr = 'foo';
+
+var obj = {
+ baz: 'bar',
+ set [expr](v) { this.baz = v; }
+};
+
+console.log(obj.baz); // "bar"
+obj.foo = 'baz'; // run the setter
+console.log(obj.baz); // "baz"
+</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('ES5.1', '#sec-11.1.5', 'Object Initializer')}}</td>
+ <td>{{Spec2('ES5.1')}}</td>
+ <td>Initiale Definition.</td>
+ </tr>
+ <tr>
+ <td>{{SpecName('ES6', '#sec-method-definitions', 'Method definitions')}}</td>
+ <td>{{Spec2('ES6')}}</td>
+ <td>Berechnete Eigenschaftsnamen hinzugefügt.</td>
+ </tr>
+ <tr>
+ <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td>
+ <td>{{Spec2('ESDraft')}}</td>
+ <td> </td>
+ </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.functions.set")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li><a href="/de/docs/Web/JavaScript/Reference/Functions/get">Getter</a></li>
+ <li>{{jsxref("Operators/delete", "delete")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.defineGetter", "__defineGetter__")}}</li>
+ <li>{{jsxref("Object.defineSetter", "__defineSetter__")}}</li>
+ <li><a href="/de/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">Defining Getters and Setters</a> im JavaScript Guide</li>
+</ul>