diff options
Diffstat (limited to 'files/de/web/javascript/reference/global_objects/reflect')
3 files changed, 343 insertions, 0 deletions
diff --git a/files/de/web/javascript/reference/global_objects/reflect/apply/index.html b/files/de/web/javascript/reference/global_objects/reflect/apply/index.html new file mode 100644 index 0000000000..bc16c4d4d8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/reflect/apply/index.html @@ -0,0 +1,98 @@ +--- +title: Reflect.apply() +slug: Web/JavaScript/Reference/Global_Objects/Reflect/apply +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/apply +--- +<div>{{JSRef}}</div> + +<div>Die statische Methode <code><strong>Reflect</strong></code><strong><code>.apply()</code></strong> ruft eine Zielfunktion mit den spezifizierten Parametern auf.</div> + +<div> </div> + +<div>{{EmbedInteractiveExample("pages/js/reflect-apply.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Reflect.apply(target, thisParameter, listeDerArgumente) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>target</dt> + <dd>Die Funktion, die aufgerufen werden soll.</dd> + <dt>thisParameter</dt> + <dd>Der Wert von <code>this</code> der für den Aufruf bereitgestellt wird.</dd> + <dt>listeDerArgumente</dt> + <dd>Ein Array ähnliches Objekt welches die Parameter spezifiziert, mit denen die Zielfunktion aufgerufen wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das Resultat des Aufruft, der Zielfunktion mit dem mitgegebenen <code>this</code> und den mitgegebenen Parametern.</p> + +<h3 id="Ausnahmen">Ausnahmen</h3> + +<p>Es wird ein {{jsxref("TypeError")}} geworfen, wenn die Zielfunktion nicht aufrufbar ist.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>In ES5, ruft man typischerweise {{jsxref("Function.prototype.apply()")}} auf, um eine Funktion aufzurufen, der man einen bestimmten <code>this</code> mitgeben und die Parameter als Array (oder einem <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects">array-like object</a>) definieren möchte.</p> + +<pre class="brush: js">Function.prototype.apply.call(Math.floor, undefined, [1.75]);</pre> + +<p>Durch <code>Reflect.apply</code> wird dieses Vorhaben kürzer und ist leichter zu verstehen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_Reflect.apply()">Verwendung von <code>Reflect.apply()</code></h3> + +<pre class="brush: js">Reflect.apply(Math.floor, undefined, [1.75]); +// 1; + +Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]); +// "hello" + +Reflect.apply(RegExp.prototype.exec, /ab/, ['confabulation']).index; +// 4 + +Reflect.apply(''.charAt, 'ponies', [3]); +// "i" +</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-reflect.apply', 'Reflect.apply')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Ursprüngliche Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.apply', 'Reflect.apply')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_kompabilität">Browser kompabilität</h2> + + + +<p>{{Compat("javascript.builtins.Reflect.apply")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Function.prototype.apply()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/reflect/construct/index.html b/files/de/web/javascript/reference/global_objects/reflect/construct/index.html new file mode 100644 index 0000000000..29da55d15b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/reflect/construct/index.html @@ -0,0 +1,157 @@ +--- +title: Reflect.construct() +slug: Web/JavaScript/Reference/Global_Objects/Reflect/construct +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/construct +--- +<div>{{JSRef}}</div> + +<div>Die statische Methode <code><strong>Reflect</strong></code><strong><code>.construct()</code></strong> verhält sich wie der <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> operator</a>, allerdings in Form einer Funktion.</div> + +<div>Sie ist das Equivalent zu <code>new target(...args)</code>. Es existiert zudem die Option, einen anderen Prototyp zu definieren.</div> + +<div> </div> + +<div>{{EmbedInteractiveExample("pages/js/reflect-construct.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Reflect.construct(target, listeDerArgumente[, newTarget]) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>target</dt> + <dd>Die Funktion, die aufgerufen werden soll.</dd> + <dt>listeDerArgumente</dt> + <dd>Ein Array ähnliches Objekt welches die Parameter spezifiziert, mit denen die Zielfunktion aufgerufen wird.</dd> + <dt><code>newTarget</code> {{optional_inline}}</dt> + <dd>Der Construktor dessen Typ genutzt werden soll. Siehe auch den <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a></code> Operator. Wenn <code>newTarget</code> nicht existiert, ist es <code>target</code>.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine neue Instanz des <code>target</code> (oder <code>newTarget</code>, wenn vorhanden), Initialisiert durch das <code>target</code> als Konstruktor mit den gegebenen Parametern.</p> + +<h3 id="Ausnahmen">Ausnahmen</h3> + +<p>Es wird ein {{jsxref("TypeError")}} geworfen, Wenn <code>target</code> or <code>newTarget</code> keine Konstruktoren sind.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>Reflect.construct</code> erlaubt es dir, einen Konstruktor mit einer variablen Anzahl von Parametern aufzurufen. (Was auch möglich ist, bai Verwendung des <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a> in Kombination mit dem <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new operator</a>).</p> + +<pre class="brush: js">var obj = new Foo(...args); +var obj = Reflect.construct(Foo, args); +</pre> + +<p> </p> + +<h3 id="Reflect.construct()_vs_Object.create()"><code>Reflect.construct()</code> vs <code>Object.create()</code></h3> + +<p>Befor wir mit der Einführung von <code>Reflect</code> beginnen. Objekte können durch von <code>Object.create()</code> mithilfe einer beliebigen Kombination aus Konstruktor und Prototyp erstellt werden.</p> + +<pre class="brush: js">function OneClass() { + this.name = 'one'; +} + +function OtherClass() { + this.name = 'other'; +} + +// Calling this: +var obj1 = Reflect.construct(OneClass, args, OtherClass); + +// ...has the same result as this: +var obj2 = Object.create(OtherClass.prototype); +OneClass.apply(obj2, args); + +console.log(obj1.name); // 'one' +console.log(obj2.name); // 'one' + +console.log(obj1 instanceof OneClass); // false +console.log(obj2 instanceof OneClass); // false + +console.log(obj1 instanceof OtherClass); // true +console.log(obj2 instanceof OtherClass); // true +</pre> + +<p>Obwohl das Endergebnis das gleiche ist, gibt es einen wichtigen Unterschied im Prozess.</p> + +<p>Wenn <code>Object.create()</code> und <code>Function.prototype.apply()</code> verwendet werden, zeigt der <code>new.target</code> Operator innerhalb der als Konstruktor verwendeten Funktion auf <code>undefined</code>, da das <code>newTarget</code> nicht zum Erstellen des Objekts verwendet wird.</p> + +<p>Wenn Sie dagegen <code>Reflect.construct()</code> aufrufen, zeigt der <code>new.target</code> Operator auf den <code>newTarget</code> Parameter, sofern angegeben und auf <code>target</code>, falls nicht.</p> + +<pre class="brush: js">function OneClass() { + console.log('OneClass'); + console.log(new.target); +} +function OtherClass() { + console.log('OtherClass'); + console.log(new.target); +} + +var obj1 = Reflect.construct(OneClass, args); +// Output: +// OneClass +// function OneClass { ... } + +var obj2 = Reflect.construct(OneClass, args, OtherClass); +// Output: +// OneClass +// function OtherClass { ... } + +var obj3 = Object.create(OtherClass.prototype); +OneClass.apply(obj2, args); +// Output: +// OneClass +// undefined</pre> + +<p> </p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_Reflect.construct()">Verwendung <code>Reflect.construct()</code></h3> + +<pre class="brush: js">var d = Reflect.construct(Date, [1776, 6, 4]); +d instanceof Date; // true +d.getFullYear(); // 1776 +</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-reflect.construct', 'Reflect.construct')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Ursprüngliche Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.construct', 'Reflect.construct')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_kompabilität">Browser kompabilität</h2> + + + +<p>{{Compat("javascript.builtins.Reflect.construct")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code></a></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a></code></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/reflect/index.html b/files/de/web/javascript/reference/global_objects/reflect/index.html new file mode 100644 index 0000000000..3ba358f140 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/reflect/index.html @@ -0,0 +1,88 @@ +--- +title: Reflect +slug: Web/JavaScript/Reference/Global_Objects/Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect +--- +<div>{{JSRef}}</div> + +<div>Reflect ist ein Standardobjekt, das Methoden für abfangfähige JavaScript-Operationen bereitstellt.</div> + +<div>Die Methoden entsprechen denen des <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler">proxy handlers</a>.</div> + +<div><code>Reflect</code> ist kein Funktionsobjekt und verfügt daher über keinen Konstruktor.</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Im Gegensatz zu den meisten globalen Objekten hat <code>Reflect</code> keinen Konstruktor. Sie können es nicht mit einem <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> operator</a> verwenden, oder <code>Reflect</code> als Funktion aufrufen.</p> + +<p>Alle Eigenschaften und Methoden von <code>Reflect</code> sind statisch (wie bei {{jsxref("Math")}}).</p> + +<h2 id="Methoden">Methoden</h2> + +<p>Das <code>Reflect</code>-Objekt stellt die folgenden statischen Funktionen bereit, die dieselben Namen haben wie die Methoden des <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler">proxy handler</a>. Einige dieser Methoden sind exakt die selben wie bei entsprechenden Methoden des {{jsxref("Object")}}.</p> + +<dl> + <dt>{{jsxref("Reflect.apply()")}}</dt> + <dd>Ruft eine Zielfunktion mit Argumenten auf, die Argumente werden im Parameter args angegeben. Siehe auch {{jsxref("Function.prototype.apply()")}}.</dd> + <dt>{{jsxref("Reflect.construct()")}}</dt> + <dd> Der <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> operator</a> als Funktion. Equivalent zu <code>new target(...args)</code>. Bietet die optionale Möglichkeit, einen anderen Prototyp anzugeben.</dd> + <dt>{{jsxref("Reflect.defineProperty()")}}</dt> + <dd>Ähnlich zu {{jsxref("Object.defineProperty()")}}. Gibt einen {{jsxref("Boolean")}} zurück.</dd> + <dt>{{jsxref("Reflect.deleteProperty()")}}</dt> + <dd>Der <a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete"><code>delete</code> operator</a> als Funktion. Ähnlich zu dem Aufruf <code>delete target[name]</code>.</dd> + <dt>{{jsxref("Reflect.get()")}}</dt> + <dd>Eine Funktion, die den Wert von Eigenschaften/Properties zurückgibt.</dd> + <dt>{{jsxref("Reflect.getOwnPropertyDescriptor()")}}</dt> + <dd>Ähnlich zu {{jsxref("Object.getOwnPropertyDescriptor()")}}. Gibt einen Eigenschaftsdeskriptor der angegebenen Eigenschaft, oder {{jsxref("undefined")}} zurück.</dd> + <dt>{{jsxref("Reflect.getPrototypeOf()")}}</dt> + <dd>Gleich wie {{jsxref("Object.getPrototypeOf()")}}.</dd> + <dt>{{jsxref("Reflect.has()")}}</dt> + <dd>Der <a href="/en-US/docs/Web/JavaScript/Reference/Operators/in"><code>in</code> operator</a> als Funktion. Gibt einen booleschen Wert zurück, der angibt, ob eine eigene oder geerbte Eigenschaft vorhanden ist.</dd> + <dt>{{jsxref("Reflect.isExtensible()")}}</dt> + <dd>Gleich wie {{jsxref("Object.isExtensible()")}}.</dd> + <dt>{{jsxref("Reflect.ownKeys()")}}</dt> + <dd>Gibt ein Array der eigenen (nicht geerbten) Eigenschaftsschlüssel des Zielobjekts zurück.</dd> + <dt>{{jsxref("Reflect.preventExtensions()")}}</dt> + <dd>Ähnlich zu {{jsxref("Object.preventExtensions()")}}. Gibt einen {{jsxref("Boolean")}} zurück.</dd> + <dt>{{jsxref("Reflect.set()")}}</dt> + <dd>Eine Funktion, die den Eigenschaften/Properties Werte zuweist. Gibt einen {{jsxref("Boolean")}} zurück, der <code>true</code> ist, wenn die Zuweisung erfolgreich verlief.</dd> + <dt>{{jsxref("Reflect.setPrototypeOf()")}}</dt> + <dd> + <p>Eine Funktion, die den Prototyp eines Objekts festlegt<span style="font-size: 1rem; letter-spacing: -0.00278rem;">.</span></p> + </dd> +</dl> + +<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-reflect-object', 'Reflect')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Ursprüngliche Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect-object', 'Reflect')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Reflect.enumerate wurde entfernt.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_kompatiblität">Browser kompatiblität</h2> + + + +<p>{{Compat("javascript.builtins.Reflect")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>Das globale {{jsxref("Proxy")}} Objekt.</li> + <li>Das {{jsxref("Proxy.handler", "handler")}} Objekt.</li> +</ul> |