Übersicht

Proxy und Reflect sind APIs, die von ES6 für das Arbeiten mit Objekten eingeführt wurden.

Proxy kann Operationen auf dem Zielobjekt abfangen, wie z. B. Lesezugriffe und Funktionsaufrufe, und dann eine Operationsverarbeitung durchführen. Es arbeitet nicht direkt mit dem Objekt, sondern wie das Proxy-Muster über ein Proxy-Objekt des Objekts, und während dieser Operationen können zusätzliche erforderliche Operationen hinzugefügt werden.

Reflect kann verwendet werden, um das Verhalten des Zielobjekts zu ermitteln. Es ähnelt Object, ist aber besser lesbar und bietet eine elegantere Möglichkeit, mit Objekten zu arbeiten. Seine Methoden entsprechen Proxy.


Grundlegende Verwendung

Proxy

Ein Proxy-Objekt besteht aus zwei Teilen: target und handler. Beim Erstellen eines Instanzobjekts über den Proxy-Konstruktor müssen diese beiden Parameter angegeben werden. target ist das Zielobjekt, und handler ist ein Objekt, das das angegebene Verhalten für das Proxying von target deklariert.

let target = { name: 'Tom', age: 24 } let handler = { get: function(target, key) { console.log('getting '+key); return target[key]; //Nicht target.key }, set: function(target, key, value) { console.log('Setzen '+key); target[key] = value; } } let proxy = new Proxy(target, handler) proxy.name //Führt tatsächlich handler.get aus proxy.age = 25 //Führt tatsächlich handler.set aus // name wird abgerufen // age wird gesetzt // 25 //target kann ein leeres Objekt sein let targetEpt = {} let proxyEpt = new Proxy(targetEpt, handler) //Rufe die get-Methode auf. Zu diesem Zeitpunkt ist das target-Objekt leer und hat keine name-Eigenschaft. proxyEpt.name // name wird abgerufen //Rufe die set-Methode auf, um die name-Eigenschaft zum target-Objekt hinzuzufügen. proxyEpt.name = 'Tom' // name setzen // "Tom" //Rufen Sie get erneut auf. Zu diesem Zeitpunkt existiert die Eigenschaft name bereits. proxyEpt.name // name abrufen // "Tom" //Wenn eine neue Instanz über den Konstruktor erstellt wird, wird tatsächlich eine flache Kopie des Zielobjekts erstellt, sodass das Zielobjekt und das Proxy-Objekt sich gegenseitig //beeinflussen targetEpt // {name: "Tom"} //Das Handler-Objekt kann auch leer sein, was gleichbedeutend damit ist, keine Abfangoperationen festzulegen und direkt auf das Zielobjekt zuzugreifen. let targetEmpty = {} let proxyEmpty = new Proxy(targetEmpty,{}) proxyEmpty.name = "Tom" targetEmpty // {name: "Tom"}

Instanzmethoden

get(target, propKey, receiver)

Wird für die Leseoperation von propKey auf dem Zielobjekt verwendet.

let exam ={ name: "Tom", age: 24 } let proxy = new Proxy(exam, { get(target, propKey, receiver) { console.log('Hole ' + propKey); return target[propKey]; } }) proxy.name // Hole name // "Tom"

Die Methode get() kann vererbt werden.

let proxy = new Proxy({}, { get(target, propKey, receiver) { //Leseschutz für private Eigenschaften implementieren if(propKey[0] === '_'){ throw new Erro(`Ungültiger Versuch zum Abrufen von privaten "${propKey}"`); } console.log('Hole ' + propKey); return target[propKey]; } }); let obj = Object.create(proxy); obj.name // Name abrufen
set(target, propKey, value, receiver)

Wird verwendet, um die Zuweisungsoperation von propKey auf dem Zielobjekt abzufangen. Wenn eine Eigenschaft des Zielobjekts selbst nicht beschreibbar und nicht konfigurierbar ist, hat die set-Methode keine Wirkung.

let validator = { set: function(obj, prop, value) { if (prop === 'age') { if (!Number.isInteger(value)) { throw new TypeError('Das Alter ist keine ganze Zahl'); } if (value > 200) { throw new RangeError('Das Alter scheint ungültig zu sein'); } } //Für die Eigenschaft age und andere Eigenschaften, die die Bedingungen erfüllen, speichere sie direkt. obj[prop] = value; } }; let proxy= new Proxy({}, validator) proxy.age = 100; proxy.age // 100 proxy.age = 'oppps' //Fehler gemeldet proxy.age = 300 //Fehler gemeldet

Der vierte Parameter receiver repräsentiert das Objekt, in dem sich das ursprüngliche Operationsverhalten befindet, in der Regel die Proxy-Instanz selbst.

const handler = { set: function(obj, prop, value, receiver) { obj[prop] = receiver; } }; const proxy = new Proxy({}, handler); proxy.name= 'Tom'; proxy.name=== proxy // true const exam = {} Object.setPrototypeOf(exam, proxy) exam.name = "Tom" exam.name === exam // wahr

Hinweis: Im strikten Modus wird ein Fehler gemeldet, wenn der set-Proxy nicht true zurückgibt.

apply(target, ctx, args)

Wird verwendet, um Funktionsaufrufe, call- und reply-Operationen abzufangen. target repräsentiert das Zielobjekt, ctx repräsentiert den Kontext des Zielobjekts und args repräsentiert das Argumentarray des Zielobjekts.

function sub(a, b){ return a - b; } let handler = { apply: function(target, ctx, args){ console.log('handle apply'); return Reflect.apply(...arguments); } } let proxy = new Proxy(sub, handler) proxy(2, 1) // handle apply // 1
has(target, propKey)

Wird verwendet, um die HasProperty-Operation abzufangen, das heißt, wenn ermittelt wird, ob das Zielobjekt die Eigenschaft propKey besitzt, wird dies von dieser Methode abgefangen. Diese Methode bestimmt nicht, ob eine Eigenschaft eine eigene Eigenschaft eines Objekts oder eine geerbte Eigenschaft ist.

let handler = { has: function(target, propKey){ console.log("handle has"); return propKey in target; } } let exam = {name: "Tom"} let proxy = new Proxy(exam, handler) 'name' in proxy // handle has // true

Hinweis: Diese Methode fängt for...in-Schleifen nicht ab.

construct(target, args)

Wird verwendet, um den new-Befehl abzufangen. Der Rückgabewert muss ein Objekt sein.

let handler = { construct: function (target, args, newTarget) { console.log('handle construct') return Reflect.construct(target, args, newTarget) } } class Exam { constructor (name) { this.name = name } } let ExamProxy = new Proxy(Exam, handler) let proxyObj = new ExamProxy('Tom') console.log(proxyObj) // construct abfangen // exam {name: "Tom"}
deleteProperty(target, propKey)

Wird verwendet, um die delete-Operation abzufangen. Wenn diese Methode einen Fehler wirft oder false zurückgibt, kann die Eigenschaft propKey nicht durch den delete-Befehl gelöscht werden.

defineProperty(target, propKey, propDesc)

Wird verwendet, um Object.definePro abzufangen. Wenn das Zielobjekt nicht erweiterbar ist, führt das Hinzufügen einer Eigenschaft, die auf dem Zielobjekt nicht existiert, zu einem Fehler; wenn eine Eigenschaft nicht beschreibbar oder nicht konfigurierbar ist, können diese Eigenschaften nicht geändert werden.

let handler = { defineProperty: function(target, propKey, propDesc){ console.log("defineProperty abfangen"); return true; } } let target = {} let proxy = new Proxy(target, handler) proxy.name = "Tom" // behandle defineProperty target // {name: "Tom"} //Wenn defineProperty false zurückgibt, ist die Operation zum Hinzufügen der Eigenschaft ungültig. let handler1 = { defineProperty: function(target, propKey, propDesc){ console.log("defineProperty abfangen"); return false; } } let target1 = {} let proxy1 = new Proxy(target1, handler1) proxy1.name = "Jerry" target1 // {}

erty Operation

getOwnPropertyDescriptor(target, propKey)

Wird verwendet, um Object.getOwnPropertyD() abzufangen. Der Rückgabewert ist ein Eigenschaftsdeskriptor-Objekt oder undefined.

let handler = { getOwnPropertyDescriptor: function(target, propKey){ return Object.getOwnPropertyDescriptor(target, propKey); } } let target = {name: "Tom"} let proxy = new Proxy(target, handler) Object.getOwnPropertyDescriptor(proxy, 'name') // {value: "Tom", writable: true, enumerable: true, configurable: // true}

ptor property

getPrototypeOf(target)

Hauptsächlich verwendet, um Operationen abzufangen, die den Objektprototyp abrufen. Enthält die folgenden Operationen:

- Object.prototype._proto_
- Object.prototype.isPrototypeOf()
- Object.getPrototypeOf()
- Reflect.getPrototypeOf()
- instanceof
let exam = {} let proxy = new Proxy({},{ getPrototypeOf: function(target){ return exam; } }) Object.getPrototypeOf(proxy) // {}

Hinweis: Der Rückgabewert muss ein Objekt oder null sein, andernfalls wird ein Fehler gemeldet. Wenn das Zielobjekt nicht erweiterbar ist, muss die Methode getPrototypeOf außerdem das Prototypobjekt des Zielobjekts zurückgeben.

let proxy = new Proxy({},{ getPrototypeOf: function(target){ return true; } }) Object.getPrototypeOf(proxy) // TypeError: 'getPrototypeOf' bei proxy: Trap gab weder ein Objekt // noch null zurück
isExtensible(target)

Wird verwendet, um die Operation Object.isExtensible abzufangen.

Diese Methode kann nur einen booleschen Wert zurückgeben; andernfalls wird der Rückgabewert automatisch in einen booleschen Wert umgewandelt.

let proxy = new Proxy({},{ isExtensible:function(target){ return true; } }) Object.isExtensible(proxy) // true

Hinweis: Der Rückgabewert muss mit der isExtensible-Eigenschaft des Zielobjekts übereinstimmen, andernfalls wird ein Fehler ausgelöst.

let proxy = new Proxy({},{ isExtensible:function(target){ return false; } }) Object.isExtensible(proxy) // TypeError: 'isExtensible' bei proxy: Trap-Ergebnis spiegelt nicht // die Erweiterbarkeit des Proxy-Ziels wider (was 'true' ist)
ownKeys(target)

Wird verwendet, um den Lesevorgang der eigenen Eigenschaften eines Objekts abzufangen. Umfasst hauptsächlich die folgenden Operationen:

- Object.getOwnPropertyNames()
- Object.getOwnPropertySymbols()
- Object.keys()
- or...in

Die von der Methode zurückgegebenen Array-Elemente dürfen nur Strings oder Symbol-Werte sein, andernfalls wird ein Fehler gemeldet.

Wenn das Zielobjekt nicht konfigurierbare Eigenschaften enthält, müssen diese Eigenschaften im Ergebnis zurückgegeben werden, andernfalls wird ein Fehler gemeldet.

Wenn das Zielobjekt nicht erweiterbar ist, muss es alle und nur alle im Zielobjekt enthaltenen Eigenschaften zurückgeben; es darf keine nicht existierenden Eigenschaften enthalten, andernfalls wird ebenfalls ein Fehler gemeldet.

let proxy = new Proxy( { name: "Tom", age: 24 }, { ownKeys(target) { return ['name']; } }); Object.keys(proxy) //[ 'name' ]f Im zurückgegebenen Ergebnis werden drei Arten von Eigenschaften herausgefiltert: //- Eigenschaften, die nicht auf dem Zielobjekt vorhanden sind //- Eigenschaften, deren Namen Symbol-Werte sind //- Nicht aufzählbare Eigenschaften let target = { name: "Tom", [Symbol.for('age')]: 24, }; //Füge eine nicht aufzählbare Eigenschaft 'gender' hinzu Object.defineProperty(target, 'gender', { enumerable: false, configurable: true, writable: true, value: 'male' }); let handler = { ownKeys(target) { return ['name', 'parent', Symbol.for('age'), 'gender']; } }; let proxy = new Proxy(target, handler); Object.keys(proxy) // ['name']
preventExtensions(target)

Fange die Operation Object.preventExtensions ab.

Diese Methode muss einen booleschen Wert zurückgeben, andernfalls wird sie automatisch in einen booleschen Wert umgewandelt.

//Nur wenn das Zielobjekt nicht erweiterbar ist (d. h., Object.isExtensible(proxy) ist false), //kann proxy.preventExtensions true zurückgeben; andernfalls wird ein Fehler gemeldet var proxy = new Proxy({}, { preventExtensions: function(target) { return true; } }); //Weil proxy.preventExtensions true zurückgibt, gibt es hier ebenfalls true zurück, daher wird ein Fehler gemeldet Object.preventExtensions(proxy)gibt einen Fehler aus:// TypeError: 'preventExtensions' auf Proxy: Trap hat truish zurückgegeben, aber // das Proxy-Ziel ist erweiterbar //Lösung var proxy = new Proxy({}, { preventExtensions: function(target) { //Object.preventExtensions vor der Rückgabe aufrufen Object.preventExtensions(target); return true; } }); Object.preventExtensions(proxy) // Proxy {}
setPrototypeOf

Wird hauptsächlich verwendet, um die Methode Object.setPrototypeOf abzufangen.

Der Rückgabewert muss ein boolescher Wert sein, andernfalls wird er automatisch in einen booleschen Wert umgewandelt.

Wenn das Zielobjekt nicht erweiterbar ist, darf die Methode setPrototypeOf den Prototyp des Zielobjekts nicht ändern.

let proto = {} let proxy = new Proxy(function () {}, { setPrototypeOf: function(target, proto) { console.log("setPrototypeOf"); return true; } } ); Object.setPrototypeOf(proxy, proto); // setPrototypeOf
Proxy.revocable()

Wird verwendet, um eine widerrufbare Proxy-Instanz zurückzugeben.

let {proxy, revoke} = Proxy.revocable({}, {}); proxy.name = "Tom"; revoke(); proxy.name // TypeError: 'get' kann nicht auf einem Proxy ausgeführt werden, der widerrufen wurde

Reflect

In ES6 wurden einige Methoden von Object, die eindeutig zu den Sprachinterna gehören, in das Reflect-Objekt verschoben (derzeit existieren einige Methoden sowohl auf dem Object- als auch auf dem Reflect-Objekt), und zukünftige neue Methoden werden nur auf dem Reflect-Objekt bereitgestellt.

Das Reflect-Objekt hat die Rückgabewerte einiger Methoden geändert, um sie sinnvoller zu machen.

Das Reflect-Objekt verwendet Funktionen, um die imperativen Operationen von Object zu implementieren.

Statische Methoden

Reflect.get(target, name, receiver)

Sucht die Eigenschaft name des Zielobjekts und gibt sie zurück.

let exam = { name: "Tom", age: 24, get info(){ return this.name + this.age; } } Reflect.get(exam, 'name'); // "Tom" //Wenn das Zielobjekt eine Getter-Methode für die Eigenschaft name hat, wird das this der Getter-Methode an // receiver gebunden let receiver = { name: "Jerry", age: 20 } Reflect.get(exam, 'info', receiver); // Jerry20 //Wenn name eine Eigenschaft ist, die auf dem Zielobjekt nicht existiert, wird undefined zurückgegeben Reflect.get(exam, 'birth'); // undefined //Wenn target kein Objekt ist, wird ein Fehler gemeldet Reflect.get(1, 'name'); // TypeError
Reflect.set(target, name, value, receiver)

Setzt die Eigenschaft name von target auf value. Der Rückgabewert ist boolean; true bedeutet Erfolg, false bedeutet Fehler. Wenn target ein nicht existierendes Objekt ist, wird ein Fehler gemeldet.

let exam = { name: "Tom", age: 24, set info(value){ return this.age = value; } } exam.age; // 24 Reflect.set(exam, 'age', 25); // true exam.age; // 25 //Wenn der Wert leer ist, wird die Eigenschaft name entfernt. Reflect.set(exam, 'age', ); // true exam.age; // undefined //Wenn das Zielobjekt eine Setter-Methode für die Eigenschaft name hat, wird das this in der Setter-Methode an // receiver gebunden, sodass tatsächlich die Eigenschaft von receiver geändert wird, let receiver = { age: 18 } Reflect.set(exam, 'info', 1, receiver); // true receiver.age; // 1 let receiver1 = { name: 'oppps' } Reflect.set(exam, 'info', 1, receiver1); receiver1.age; // 1
Reflect.has(obj, name)

Es ist die funktionale Form des Operators name in obj und wird verwendet, um zu überprüfen, ob die Eigenschaft name im Objekt obj vorhanden ist. Der Rückgabewert ist boolesch. Wenn obj kein Objekt ist, wird ein TypeError gemeldet.

let exam = { name: "Tom", age: 24 } Reflect.has(exam, 'name'); // true
Reflect.deleteProperty(obj, property)

Es ist die funktionale Form von delete obj[property] und wird verwendet, um die Eigenschaft property des Objekts obj zu löschen. Der Rückgabewert ist boolesch. Wenn obj kein Objekt ist, wird ein TypeError gemeldet.

let exam = { name: "Tom", age: 24 } Reflect.deleteProperty(exam , 'name'); // true exam // {age: 24} //Wenn die Eigenschaft nicht existiert, wird ebenfalls true zurückgegeben Reflect.deleteProperty(exam , 'name'); // wahr
Reflect.construct(obj, args)

Entspricht new target(...args).

function exam(name){ this.name = name; } Reflect.construct(exam, ['Tom']); // exam {name: "Tom"}
Reflect.getPrototypeOf(obj)

Wird verwendet, um die Eigenschaft _proto_ von obj zu lesen. Wenn obj kein Objekt ist, wird obj nicht wie bei Object in ein Objekt umgewandelt, sondern es wird ein Fehler gemeldet.

class Exam{} let obj = new Exam() Reflect.getPrototypeOf(obj) === Exam.prototype // true
Reflect.setPrototypeOf(obj, newProto)

Wird verwendet, um den Prototyp des Zielobjekts festzulegen.

let obj ={} Reflect.setPrototypeOf(obj, Array.prototype); // true
Reflect.apply(func, thisArg, args)

Entspricht Function.prototype.apply.call(func, thisArg, args). func repräsentiert die Zielfunktion; thisArg repräsentiert das an die Zielfunktion gebundene this-Objekt; args repräsentiert die Argumentliste, die beim Aufruf der Zielfunktion übergeben wird, und kann ein Array oder ein Array-ähnliches Objekt sein. Wenn die Zielfunktion nicht aufgerufen werden kann, wird ein TypeError ausgelöst.

Reflect.apply(Math.max, Math, [1, 3, 5, 3, 1]); // 5
Reflect.defineProperty(target, propertyKey, attributes)

Wird verwendet, um Eigenschaften für das Zielobjekt zu definieren. Wenn target kein Objekt ist, wird ein Fehler ausgelöst.

let myDate= {} Reflect.defineProperty(MyDate, 'now', { value: () => Date.now() }); // true const student = {}; Reflect.defineProperty(student, "name", {value: "Mike"}); // true student.name; // "Mike"
Reflect.getOwnPropertyDescriptor(target, propertyKey)

Wird verwendet, um das Deskriptorobjekt der Eigenschaft propertyKey des Zielobjekts abzurufen. Wenn target kein Objekt ist, wird ein Fehler ausgelöst, um einen ungültigen Parameter anzuzeigen; das Nicht-Objekt wird nicht in ein Objekt umgewandelt.

var exam = {} Reflect.defineProperty(exam, 'name', { value: true, enumerable: false, }) Reflect.getOwnPropertyDescriptor(exam, 'name') // { configurable: false, enumerable: false, value: true, writable: // false} //Wenn die Eigenschaft propertyKey auf dem Zielobjekt nicht existiert, wird undefined zurückgegeben. Reflect.getOwnPropertyDescriptor(exam, 'age') // undefined
Reflect.isExtensible(target)

Wird verwendet, um zu bestimmen, ob das Zielobjekt erweiterbar ist. Der Rückgabewert ist ein boolescher Wert. Wenn der target-Parameter kein Objekt ist, wird ein Fehler ausgelöst.

let exam = {} Reflect.isExtensible(exam) // true
Reflect.preventExtensions(target)

Wird verwendet, um das Zielobjekt nicht erweiterbar zu machen. Wenn der Parameter target kein Objekt ist, wird ein Fehler ausgelöst.

let exam = {} Reflect.preventExtensions(exam) // true
Reflect.ownKeys(target)

Wird verwendet, um alle Eigenschaften des Zielobjekts zurückzugeben, äquivalent zur Kombination von Object.getOwnPropertyNames und Object.getOwnPropertySymbols.

var exam = { name: 1, [Symbol.for('age')]: 4 } Reflect.ownKeys(exam) // ["name", Symbol(age)]

Kombinierte Verwendung

Die Methoden des Reflect-Objekts entsprechen eins zu eins den Methoden des Proxy-Objekts. Daher können die Methoden des Proxy-Objekts Standardverhalten erhalten, indem sie die Methoden des Reflect-Objekts aufrufen und anschließend zusätzliche Operationen ausführen.

let exam = { name: "Tom", age: 24 } let handler = { get: function(target, key){ console.log("getting "+key); return Reflect.get(target,key); }, set: function(target, key, value){ console.log("setting "+key+" to "+value) Reflect.set(target, key, value); } } let proxy = new Proxy(exam, handler) proxy.name = "Jerry" proxy.name // name auf Jerry setzen // name abrufen // "Jerry"

Erweiterte Anwendungsfälle

Implementierung des Observer-Musters.

//Definiere eine Set-Sammlung. const queuedObservers = new Set(); //Füge alle Observer-Funktionen in die Set-Sammlung ein. const observe = fn => queuedObservers.add(fn); //observable gibt einen Proxy des Originalobjekts zurück und fängt Zuweisungsoperationen ab. const observable = obj => new Proxy(obj, {set}); function set(target, key, value, receiver) { //Ermittelt die Zuweisungsoperation des Objekts. const result = Reflect.set(target, key, value, receiver); //Alle Observer ausführen. queuedObservers.forEach(observer => observer()); //Die Zuweisungsoperation ausführen. return result; }