From 4b1a9203c547c019fc5398082ae19a3f3d4c3efe Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:41:15 -0500 Subject: initial commit --- .../javascript/reference/functions/get/index.html | 174 +++++++++++++++++++++ 1 file changed, 174 insertions(+) create mode 100644 files/de/web/javascript/reference/functions/get/index.html (limited to 'files/de/web/javascript/reference/functions/get') 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 +--- +
{{jsSidebar("Functions")}}
+ +

Die get Syntax bindet eine Objekteigenschaft an eine Funktion welche aufgerufen wird, wenn die Eigenschaft abgefragt wird.

+ +
{{EmbedInteractiveExample("pages/js/functions-getter.html")}}
+ + + +

Syntax

+ +
{get prop() { ... } }
+{get [expression]() { ... } }
+ +

Parameter

+ +
+
prop
+
Der Name der Eigenschaft, die an die gegebene Funktion gebunden wird.
+
expression
+
Beginnend mit ECMAScript 2015, kann auch ein Ausdruck für einen berechneten Eigenschaftsnamen genutzt werden, der an die Funktion gebunden wird.
+
+ +

Beschreibung

+ +

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 getter erreicht werden.

+ +

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.

+ +

Folgendes ist zu beachten, wenn die get Syntax verwendet wird:

+ + + +

Beispiele

+ +

Definition eines Getters in einem neuen Objekt in der Objektinitialisierung

+ +

Folgendes erstellt eine Pseudoeigenschaft latest für das Objekt obj, welche dan letzte Arrayeintrag von log zurückgibt.

+ +
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".
+
+ +

Zu beachten ist, dass die Zuweisung eines Wertes auf latest keine Änderung bewirkt.

+ +

Löschen eines Getters mit dem delete Operator

+ +

Wenn ein Getter gelöscht werden soll, kann einfach {{jsxref("Operators/delete", "delete")}} benutzt werden:

+ +
delete obj.latest;
+
+ +

Definition eines Getter auf einem existierenden Objektes mit defineProperty

+ +

Um einem Getter später zu einem existierenden Objekt hinzuzufügen, kann jederzeit {{jsxref("Object.defineProperty()")}} benutzt werden.

+ +
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)
+ +

Einen berechneten Eigenschaftnamen benutzen

+ +
const expr = 'foo';
+
+const obj = {
+  get [expr]() { return 'bar'; }
+};
+
+console.log(obj.foo); // "bar"
+ +

Intelligente / Selbstüberschreibende / Lazy Getter

+ +

Mit Gettern kann eine Eigenschaft eines Objekts definiert werden, wobei der Wert der Eigenschaft nicht berechnen 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.

+ +

Eine weitere Optimierungstechnik, um die Berechnung eines Eigenschaftswerts zu verzögern und ihn für einen späteren Zugriff zwischenzuspeichern, sind intelligente (oder "memoisierte") Getter. 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:

+ + + +
+

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.

+
+ +

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.

+ +
get notifier() {
+  delete this.notifier;
+  return this.notifier = document.getElementById('bookmarked-notification-anchor');
+},
+ +

Für Firefox Code sollte zusätzlich das XPCOMUtils.jsm Code Modul angeschaut werden, welches die defineLazyGetter() Funktion definiert.

+ +

get vs. defineProperty

+ +

Das get Schlüsselwort und {{jsxref("Object.defineProperty()")}} haben ähnliche Ergebnisse. Es gibt einen kleinen Unterschied zwischen beiden, wenn {{jsxref("classes")}} eingesetzt werden.

+ +

Wenn get eingesetzt wird, wird die Eigenschaft im Instnaz-Prototyp definiert, während beim Einsatz von {{jsxref("Object.defineProperty()")}} die Eigenschaft auf der Instanz definiert wird.

+ +
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 }
+ +

Spezifikationen

+ + + + + + + + + + + + +
Spezifikation
{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.functions.get")}}

+ +

Siehe auch

+ + -- cgit v1.2.3-54-g00ecf