Technologieaustausch

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Das Reflect-Objekt ist wie das Proxy-Objekt eine neue API, die von ES6 zum Betreiben von Objekten bereitgestellt wird. Reflektierte Objekte dienen vier Zwecken.

1. Fügen Sie einige Methoden des Object-Objekts, die offensichtlich in der Sprache enthalten sind (z. B. Object.defineProperty), in das Reflect-Objekt ein. Zu diesem Zeitpunkt werden einige Methoden sowohl für Object- als auch für Reflect-Objekte bereitgestellt, und neue Methoden werden in Zukunft nur für Reflect-Objekte bereitgestellt. Mit anderen Worten: Die internen Methoden der Sprache können vom Reflect-Objekt abgerufen werden.
2. Ändern Sie die Rückgabeergebnisse einiger Objektmethoden, um sie sinnvoller zu gestalten. Beispielsweise gibt Object.defineProperty(obj, name, desc) einen Fehler aus, wenn die Eigenschaft nicht definiert werden kann, während Reflect.defineProperty(obj, name, desc) false zurückgibt.

// 老写法
try {
  Object.defineProperty(target, property, attributes);
  // success
} catch (e) {
  // failure
}
// 新写法
if (Reflect.defineProperty(target, property, attributes)) {
  // success
} else {
  // failure
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3. Lassen Sie Objektoperationen zu funktionalen Verhaltensweisen werden. Einige Objektoperationen sind zwingend erforderlich, z. B. „Name in obj“ und „lösche obj[Name]“, aber Reflect.has(obj, name) und Reflect.deleteProperty(obj, name) wandeln sie in funktionale Verhaltensweisen um.

// 老写法
'assign' in Object // true
// 新写法
Reflect.has(Object, 'assign') // true
1
2
3
4

4. Die Methoden des Reflect-Objekts entsprechen den Methoden des Proxy-Objekts eins zu eins. Solange es sich um eine Methode des Proxy-Objekts handelt, kann die entsprechende Methode auf dem Reflect-Objekt gefunden werden. Dadurch kann das Proxy-Objekt problemlos die entsprechende Reflect-Methode aufrufen, um das Standardverhalten zu vervollständigen und als Grundlage für die Änderung des Verhaltens zu dienen. Mit anderen Worten: Unabhängig davon, wie Proxy das Standardverhalten ändert, können Sie bei Reflect immer das Standardverhalten erhalten.

Proxy(target, {
  set: function(target, name, value, receiver) {
    var success = Reflect.set(target, name, value, receiver);
    if (success) {
      console.log('property ' + name + ' on ' + target + ' set to ' + value);
    }
    return success;
  }
});
1
2
3
4
5
6
7
8
9

Die Proxy-Methode fängt das Attributzuweisungsverhalten des Zielobjekts ab. Es verwendet die Reflect.set-Methode, um den Eigenschaften des Objekts Werte zuzuweisen, um sicherzustellen, dass das ursprüngliche Verhalten vervollständigt wird, und stellt dann zusätzliche Funktionen bereit.

Häufig verwendete Methoden:

Reflect.get(target, propertyKey[, Receiver]): Ruft die Eigenschaften des Objekts ab.
Reflect.set(target, propertyKey, value[, Receiver]): Legen Sie die Eigenschaften des Objekts fest.
Reflect.has(target, propertyKey): Bestimmen Sie, ob die Eigenschaft für das Objekt vorhanden ist.
Reflect.deleteProperty(target, propertyKey): Löschen Sie die Eigenschaften des Objekts.
Reflect.ownKeys(target): Gibt ein Array aller Eigenschaften des Objekts selbst zurück.
Reflect.getOwnPropertyDescriptor(target, propertyKey): Ruft den Deskriptor der Objekteigenschaft ab.
Reflect.defineProperty(target, propertyKey, attributes): Definieren oder ändern Sie die Eigenschaften des Objekts.
Reflect.preventExtensions(target): Verhindert, dass das Objekt erweitert wird.
Reflect.isExtensible(target): Bestimmen Sie, ob das Objekt erweiterbar ist.
Reflect.getExtension(target): Ruft den Prototyp des Objekts ab.
Reflect.setPrototypeOf (Ziel, Prototyp): Legen Sie den Prototyp des Objekts fest.

Beispiel 1: Verwendung von Reflect.get

let obj = { name: "Alice", age: 25 };
let propName = "name";

console.log(Reflect.get(obj, propName)); // 输出：Alice
console.log(Reflect.get(obj, "gender")); // 输出：undefined
1
2
3
4
5

Beispiel 2: Verwendung von Reflect.set

let obj = { name: "Alice" };

// 设置属性
console.log(Reflect.set(obj, "age", 30)); // 输出：true

console.log(obj); // 输出：{ name: "Alice", age: 30 }
1
2
3
4
5
6

Beispiel 3: Verwendung von Reflect.has

let obj = { name: "Alice" };

console.log(Reflect.has(obj, "name")); // 输出：true
console.log(Reflect.has(obj, "age"));  // 输出：false
1
2
3
4

Beispiel 4: Verwendung von Reflect.deleteProperty

let obj = { name: "Alice", age: 30 };

// 删除属性
console.log(Reflect.deleteProperty(obj, "age")); // 输出：true

console.log(obj); // 输出：{ name: "Alice" }
1
2
3
4
5
6

Beispiel 5: Verwendung von Reflect.ownKeys

let obj = { name: "Alice", age: 30 };

console.log(Reflect.ownKeys(obj)); // 输出：["name", "age"]
1
2
3

Beispiel 6: Verwendung von Reflect.preventExtensions

let obj = { name: "Alice" };

// 防止对象被扩展
console.log(Reflect.preventExtensions(obj)); // 输出：true

// 尝试添加新属性
console.log(Reflect.set(obj, "age", 30)); // 输出：false
1
2
3
4
5
6
7

Beispiel 7: Verwendung von Reflect.isExtensible

let obj = { name: "Alice" };

console.log(Reflect.isExtensible(obj)); // 输出：true
1
2
3

Beispiel 8: Verwendung von Reflect.getPrototypeOf und Reflect.setPrototypeOf

let proto = { sayHello: function() { console.log("Hello!"); }};
let obj = Object.create(proto);

console.log(Reflect.getPrototypeOf(obj) === proto); // 输出：true

// 设置新原型
let newProto = { sayGoodbye: function() { console.log("Goodbye!"); }};
Reflect.setPrototypeOf(obj, newProto);

console.log(obj.sayGoodbye); // 可以访问新原型上的方法
obj.sayGoodbye(); // 输出：Goodbye!
1
2
3
4
5
6
7
8
9
10
11

Das Reflect-Objekt stellt eine Reihe von Methoden bereit, die Proxy-Traps entsprechen, wodurch das Abfangen von JavaScript-Vorgängen intuitiver und bequemer wird. Durch die Verwendung von Reflect wird die Konsistenz und das erwartete Verhalten von Vorgängen sichergestellt, insbesondere wenn Fehlerbedingungen oder Fehler explizit erfasst werden müssen.