Reflect EINLEITUNG:
Das reflektierende Objekt wurde in meinem Knoten (v4.4.3) nicht implementiert, und Babel (6.7.7) wird nicht implementiert. Die neue Version von Chrome wird unterstützt. FF hat Proxy unterstützt und lange reflektiert. Wenn Sie möchten, dass der Knoten reflektiert wird, können Sie Harmony-Reflect installieren.
Refraxs ist kein Konstruktor. Bei Verwendung wird es direkt durch reflect.method () aufgerufen. Einige Reflexmethoden ähneln den Proxy, und die meisten reflektierten Methoden, die native Objekte implementiert wurden.
Was zu bedienen ist reflektiert
Hier sind einige Gründe, warum reflektiert wird. Übersetzungsadresse: Reflektieren, grob übersetzt:
1: Mehr nützlicher Rückgabewert: Reflect hat einige Methoden wie die Objektmethode in ES5, wie z. Wenn das Objekt jedoch erfolgreich ausgeführt wird. Reflect.defineProperty gibt nur falsche oder treu zurück, um anzuzeigen, ob die Eigenschaften des Objekts festgelegt wurden. Der folgende Code kann neu gestaltet werden:
try {Object.defineProperty (OBJ, Name, Desc); // Eigentum erfolgreich definiert} catch (e) {// Möglicher Fehler (und kann versehentlich die falsche Ausnahme fangen)}}So rekonstruiert wie dieses:
if (reflect.defineProperty (obj, name, desc)) {// Erfolg} else {// fehler}Die anderen Methoden wie relect.set, reflektieren.DeletEproperty, reflektieren.
2: Funktionsbetrieb. Wenn Sie feststellen möchten, dass ein OBJ einen definierten oder den Attributnamen erbt, können Sie ihn in ES5 wie folgt beurteilen: Name in OBJ;
Oder löschen Sie ein Attribut: obj [Name] löschen. Obwohl diese sehr nützlich, sehr kurz und klar sind, müssen sie auch in eine Klasse eingekapselt werden, wenn sie verwendet werden sollen.
Mit Reflect hilft es Ihnen, zu verkörpern, reflektieren. (obj, name), reflektiert.deleteProperty (obj, name);
3: Zuverlässigere Funktionsausführungsmethode: Wenn Sie eine Funktion F ausführen möchten, und eine Reihe von Parametern übergeben und dies binden möchten, müssen Sie dies schreiben:
f.apply (obj, args)
Die F -Anwendung kann jedoch als eigene Anwendung des Benutzers neu definiert werden. Daher ist es zuverlässiger, auf diese Weise zu schreiben:
Function.prototype.apply.call (f, obj, args)
Der obige Code ist zu lang und schwer zu verstehen. Mit Reflect können wir kürzer und prägnanter und klarer sein:
Reflect.apply (f, obj, args)
4: Konstruktoren in variadischer Parameterform: Stellen Sie sich vor, Sie möchten einen Konstruktor durch Parameter unsicherer Länge instanziieren. In ES5 können wir Erweiterungssymbole verwenden, die so geschrieben werden können:
var obj = new f (... args)
In ES5 werden jedoch Erweiterungszeichen nicht unterstützt, sodass wir nur verschiedene Parameter in F.Apply oder F.Call übergeben können. Leider ist F ein Konstruktor, der ein Betrug ist, aber mit reflektierter Reflexion,
Wir können dies in ES5 schreiben:
var obj = reflect.construct (f, args)
5: Dies steuert den Accessor oder Leser: In ES5, wenn Sie die Attribute eines Elements lesen oder die Attribute wie folgt festlegen möchten:
var name = ... // Eigenschaftsname als StringObj [Name] // Generische Eigenschaft Lookupobj [Name] = Wert // Generische Eigenschaft
Die Methoden updateReflect.get und reflektieren. Set -Methoden ermöglichen es uns, dasselbe zu tun, und es fügt der Rekiver einen zusätzlichen Parameter hinzu, sodass wir den Setter des Objekts festlegen und Getter auf und ab haben:
var name = ... // Eigenschaftsname als StringReflect.get (obj, Name, Wrapper) // Wenn OBJ [Name] ein Accessor ist, wird er mit `this === Wrapper`reflect.set ausgeführt. }, bar: function () {alert (1);}}; var wrack = {bar: function () {console.log ("wrapper");}} reflect.set (obj, "foo", "value", wrapper);6: Vermeiden Sie den direkten Zugriff auf __Proto__:
ES5 bietet Object.getPrototypeof (OBJ), um auf den Prototyp des Objekts zuzugreifen, und ES6 bietet auch
Reflect.getPrototypeof (OBJ) und reflektiert.setPrototypeof (OBJ, NewProto) ist eine neue Methode zum Zugriff auf und festlegen auf den Prototyp des Objekts:
Reflektiert.Apply Nutzung
Reflect.Apply ist tatsächlich die Funktion.Prototype.Apply () Ersatz in Es5. Um reflektiert zu werden, sind drei Parameter erforderlich.
Der erste Parameter ist: Die ausführende Funktion;
Der zweite Parameter ist: der Kontext, der ausgeführt werden muss;
Der dritte Parameter ist: ist ein Array oder ein Pseudo-Array, das als Parameter verwendet wird, um die Funktion auszuführen.
<Script> let fn = function () {this.attr = [0,1,2,3];}; let obj = {}; reflektiert.Apply (fn, obj, []) console.log (obj); Demo von <Script> reflektiert.Apply: <Script> reflektiert.Apply (Math.Floor, undefiniert, [1.75]); // Ausgabe: 1; reflect.apply (String.FromCharcode, undefiniert, [104, 101, 108, 108, 111]); // Ausgabe: "Hallo" reflektiert.Apply (regexp.prototype.exec,/ab/, ["Confabulation"]). Index; // Ausgabe: 4Reflect.Apply ("". Charat, "Ponies", [3]); // Ausgabe: "i" </script> kann in Kombination mit Proxy verwendet werden: {var fn = function () {}; Ziel (... Augungen); // wie man reflect.Apply; reflect.Apply (target.Prototype.run, obj, ersgebunden); return obj;}}); neue Proxyfn (); // die Ausgabe zuerst: "Proxy Constructor"; und dann Ausgabe: Ausläuft} reflect.construct (): refled.construct ist tatsächlich ein Instanziierungskonstruktor. Es wird durch das Argumentformular implementiert. Die Ausführungsmethode ist anders. Der Effekt ist tatsächlich der gleiche. Der erste Konstruktparameter ist der Konstruktor, und der zweite Parameter ist ein Array oder ein Pseudo-Array, das aus Parametern besteht. Die grundlegende Verwendungsmethode lautet: var fn = function (arg) {this.args = [arg]}; console.log (neu fn (1), reflect.construct (fn, [1])); // Die Ausgabe ist die gleiche var d = reflektiert. // trued.getingfullyear (); // 1776 // so reflektieren.Construct und neues Konstrukt so reflektieren. Konstrukte und neues Konstrukt sind gleich, zumindest bisher können wir den dritten Parameter übergeben. Das neue Element wird diese Superklasse erben; <Script> Funktion someconstructor () {} var result = reflect.construct (array, [], someconstructor); reflect.getPrototype (Ergebnis); // someconstructor.prototypearray.isArray (Ergebnis); // true // orvar fn = function () {this.attr = [1];}; var person = function () {}; person.prototype.run = function () {}; console.log (reflektieren.Construconstruct (fn, [], Person). var fn = function () {Array.Apply (this, Argumente); this.shot = () => {console.log ("heheda");};}; var arr = reflect.construct (fn, []) reflect.defineProperty; Reflect.defineProperty gibt einen booleschen Wert zurück, und der Attributwert wird dem Objekt durch direkte Zuweisung hinzugefügt. Gibt ein ganzes Objekt zurück, wenn der Zugabe fehlschlägt, wird ein Fehler geworfen. var obj = {}; obj.x = 10; console.log (obj.x) // output: 10; Mehrwert mit Reflect.DefineProperty; <Script> var obj = {}; if (reflect.defineProperty (obj, "x", {value: 7}) {console.log ("Erfolg hinzugefügt");} else {console.log ("Erfolg hinzugefügt");}; Reflect.defineProperty und ein falscher Wert wird zurückgegeben: var obj = {}; Object.Preventextensions (obj); console.log (reflect.defineProperty (obj, "x", {value: 101}) // false zurückgeben: Wenn der Wert direkt zugewiesen wird, wird der festgelegte Wert zurückgegeben, unabhängig davon, ob der Wert korrekt zugewiesen wird, sofern wir nicht manuell bestätigen, ob der Eigenschaftswert des Objekts erfolgreich festgelegt ist. <Script> var obj = {}; // Ausgabe: 1; console.log (obj.aa) // output: undefined; </script> reflect.deletEpperty use Die Betriebsergebnisse von reflektieren. Der Unterschied besteht darin, dass die Verwendungsformen unterschiedlich sind: Einer ist ein Bediener und der andere ist ein Funktionsaufruf; Reflect.deletEproperty (Object.Freeze ({foo: 1}), "foo"); // falssedelete Object.freeze ({foo: 1}). foo; // Ausgabe: Falsch; Es gibt zwei notwendige Parameter für die Verwendung der Reflect.get () -Methode: Das erste ist das OBJ -Zielobjekt, das zweite ist das Attributname -Objekt, und das dritte ist optional, was der Kontext des Lesers ist (dies). var obj = {}; obj.foo = 1; console.log (obj.foo); // Ausgabe: 1; console.log (reflect.get (obj, "foo") // Ausgabe: 1; Wenn reflektiert.get einen dritten Parameter hat, wird der dritte Parameter als Kontext des Lesers verwendet: var reflect = fordert ('Harmony-Reflect'); var obj = {"foo": 1, gett bar () {return this.foo;}}; var foo = {}; foo.foo = "heheda"; console.log (reflect.get (obj, "bar", foo); Reflect.GetownPropertyDescriptor ({x: "Hallo"}, "x"); // Sie können es auch wie folgt bekommen: Object.getownPropertyDescriptor ({x: "1"}, "x"); // Der Unterschied zwischen diesen beiden ist, dass man das Objekt wickeln kann. // ein Ausnahmebobjekt werfen. // Ausgabe: {value: "h", beschreibbar: false, aufzählbar: true, konfigurierbar: false} reflektiert.getPrototypeof () Methodenverwendung: reflektiert.getPrototype und Object.getPrototype sind gleich, beide geben den Prototyp eines Objekts reflektiert. // Ausgabe: Object.PrototypeFlect.getPrototypeof (Object.Prototype); // Ausgabe: nullreflect.getPrototype (Object.create (null)); // Ausgabe: nullReflect.has die Methode der Verwendung reflektiert.has ist ein bisschen wie der Operator: In, zum Beispiel: xx in obj; <Script> reflect.has ({x: 0}, "x") // Ausgabe: true; Reflect.has ({y: 0}, "y") // output: true; var obj = {x: 0}; console.log ("x" in obj); var proxy = new Proxy (obj, {hat: function (Ziel, args) {console.log ("execute hat methode"); return reflect.has (Ziel, ... args);}}); console.log ("x" im Proxy); // Ausgabe: Richtig; console.log (reflect.has (proxy, "x")) // output: true; </script> Der OBJ dieser Demo entspricht einer Methode, es ist nutzlos, sie verwendet nur seine Methode: obj = neuer Proxy ({}, {Has (t, k) {return k.startswith ("Tür");}}); Refled.has (obj, "doorkling"); // TrueReflect.has (obj, "Schlafsaal"); // falsereflect.isextSible () verwenden // Jetzt kann dieses Element erweitert werden. var leer = {}; refled.isexteSible (leer); // === TRUE // Verwenden Sie die Verhinderungsmethode, um zu verhindern, dass dieses Objekt neue Attribute erweitert. Reflektiert.Preventextensionen (leer); Refled.isextesible (leer); // === false // Dieses Objekt kann neue Attribute nicht erweitern, und die beschreibbaren Attribute können weiterhin geändert werden. // === false // Dieses Objekt ist vollständig gefroren var gefroren = Objekt // === FALSE Der Unterschied zwischen reflektiert. ISEXTLINDIBLE und Object.ISEXTLINDIBLE ist, dass, wenn der Parameter nicht korrekt ist, der eine falsche wirft und der andere nur wahr oder falsch zurückgibt. Reflect.ownKeys () Methode Verwendung: refled.ownKeys, Objekt hat nicht die ownKeys -Methode, reflektiert. console.log (reflect.ownkeys ({"a": 0, "b": 1, "c": 2, "d": 3}); // Ausgabe: ["A", "B", "C", "D"] console.log (reflect.ownkeys ([])); // ["Länge"] var sym = symbol.for ("comet"); var sym2 = symbol.for ("meteor"); var obj = {[sym]: 0, "str": 0, "773": 0, "0": 0, [sym2]: 0, "-1": 0, "8": 0, "Second Str": 0}; Reflect.ownKeys (obj); // Ausgabe: /["0", "8", "773", "Str", "-1", "zweiter Str", Symbol (Komet), Symbol (Meteor)] reflektiert. Schließlich werden die Schlüssel des Symboltyps auch nach der Reihenfolge der Einfügung sortiert; Die Sortierung tritt auf, da Sie einem Objektattribut, wenn Sie einem Objektattribut einen Wert zuweisen, die Sortierregel des Objektschlüssels zuerst, in einer Zeichenfolge und schließlich die Daten des Symboltyps betrifft. Die Verwendungsmethode von reflektiert.Preventextensionen (): Objekt hat auch eine Verhinderungsmethode, die sich ein wenig von reflect.preventextensionen () unterscheidet. Wenn der Parameter von reflect.Preventextensionen kein Objekt ist, wird ein Fehler geworfen. var leer = {}; refled.isexteSible (leer); // === true // Das Objekt nach der Ausführung von Vorzeiten kann geändert werden. Reflektiert.Preventextensionen (leer); Refled.isextesible (leer); // === falsereflect.Preventextensionen (1); // TypeRror: 1 ist kein ObjectObject.Preventextensions (1); // Es wird kein Fehler geworfen. var obj = {}; reflect.set (obj, "prop", "value"); // Ausgabe: trueconsole.log (obj.prop); // Ausgabe: "Wert" var arr = ["Ente", "Duck", "Ente"]; refled.set (arr, 2, "gans"); // Trueconsole.log (arr [2]); // "Gans" reflektiert.set (arr, "Länge", 1); // trueconsole.log (arr); // ["Duck"]; refled.set (obj) ist äquivalent zu reflektieren // Ausgabe: TRUE // Der obige Code ist äquivalent zu reflektieren. {console.log ("setzter"); this.value = value;}, get key () {return this.value;}}; refled.set (obj, "key", "heheda", obj); console.log.log (OBJ); refledPrototype. Es wird einen Prototyp für das Objekt festgelegt, das das __Proto__ -Attribut des Objekts ändern soll. // Ausgabe true // an das Objektarray [[[Prototyp]] ist null.reflect.setPrototypeof ({}, null); // true // zu diesem Zeitpunkt ist obj .__ proto__ undefiniert // Das Objekt befreien und zurücksetzen. // false // Wenn die Prototyp -Kette von der Schleife abhängt, gibt sie false.var target = {}; var proto = Object.create (target); reflect.setPrototype (target, proto) zurück; // FALSCH