详解Reflect

1.概述

Reflect 是一个内置的对象，它提供拦截 JavaScript 操作的方法。这些方法与proxy handlers的方法相同。Reflect不是一个函数对象，因此它是不可构造的。

Reflect对象的设计的目的：

1. 将Object对象的一些明显属于语言内部的方法（比如Object.defineProperty），放到Reflect对象上。现阶段，某些方法同时在Object和Reflect对象上部署，未来的新方法将只部署在Reflect对象上。也就是说，从Reflect对象上可以拿到语言内部的方法。

2.修改某些Object方法的返回结果，让其变得更合理。比如，Object.defineProperty(obj, name, desc)在无法定义属性时，会抛出一个错误，而Reflect.defineProperty(obj, name, desc)则会返回false。

3.让Object操作都变成函数行为。某些Object操作是命令式，比如name in obj ，delete obj[name]， 而Reflect.has(obj, name)和Reflect.deleteProperty(obj, name)让它们变成了函数行为。

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

4.Reflect对象的方法与Proxy对象的方法一一对应，只要是Proxy对象的方法，就能在Reflect对象上找到对应的方法。这就让Proxy对象可以方便地调用对应的Reflect方法，完成默认行为，作为修改行为的基础。也就是说， 不管Proxy怎么修改默认行为，你总可以在Reflect上获取默认行为。

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; } }); 

2.静态方法

一共有13个静态方法

1.Reflect.apply(target, thisArgument, argumentsList)；

• target目标函数。
• thisArgument target函数调用时绑定的this对象。
• argumentsList target函数调用时传入的实参列表，该参数应该是一个类数组的对象。

对一个函数进行调用操作，同时可以传入一个数组作为调用参数。和Function.prototype.apply() 功能类似。

Reflect.apply(Math.floor, undefined, [1.75]); // 1; Reflect.apply("".charAt, "ponies", [3]); // "i" 

2.Reflect.construct(target, argumentsList[, newTarget])；

• target：被运行的目标构造函数
• argumentsList：类数组，目标构造函数调用时的参数。
• newTarget（可选）：作为新创建对象的原型对象的constructor属性， 参考 new.target 操作符，默认值为target。

对构造函数进行 new 操作，相当于执行 new target(…args)。该方法的行为有点像 new 操作符 构造函数 ， 相当于运行 new target(…args).

function OneClass() { 
    this.name = 'one'; } function OtherClass() { 
    this.name = 'other'; } // 创建一个对象: var obj1 = Reflect.construct(OneClass, args, OtherClass); console.log(obj1); //OtherClass {name: "one"} console.log(obj1.constructor); //ƒ OtherClass() { this.name = 'other';} // 与上述方法等效: 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 

3.Reflect.defineProperty(target, propertyKey, attributes)；

• target：目标对象。
• propertyKey：要定义或修改的属性的名称。
• attributes：要定义或修改的属性的描述。

let obj = { 
   } Reflect.defineProperty(obj, 'x', { 
   value: 7}) // true obj.x // 7 

4.Reflect.deleteProperty(target, propertyKey)；

• target：删除属性的目标对象。
• propertyKey：需要删除的属性的名称。

作为函数的delete操作符，相当于执行 delete target[name]。返回布尔值

var obj = { 
    x: 1, y: 2 }; Reflect.deleteProperty(obj, "x"); // true obj; // { y: 2 } 

5.Reflect.get(target, propertyKey[, receiver])；

• target：需要取值的目标对象
• propertyKey：需要获取的值的键值
• receiver：如果target对象中指定了getter，receiver则为getter调用时的this值。

Reflect.get方法允许你从一个对象中取属性值。就类似于 target[name]。，但却是通过函数调用来实现。

// Object var obj = { 
    x: 1, y: 2 }; Reflect.get(obj, "x"); // 1 // Array Reflect.get(["zero", "one"], 1); // "one" 

6.Reflect.set(target, propertyKey, value[, receiver])

• target：设置属性的目标对象。
• propertyKey：设置的属性的名称。
• value：设置的值。
• receiver：如果遇到 setter，receiver则为setter调用时的this值。

Reflect.set 方法允许你在对象上设置属性，如果更新成功，则返回true。它的作用是给属性赋值并且就像 property accessor 语法一样，但是它是以函数的方式。

// Object var obj = { 
   }; Reflect.set(obj, "prop", "value"); // true obj.prop; // "value" // Array var arr = ["duck", "duck", "duck"]; Reflect.set(arr, 2, "goose"); // true arr; // ["duck", "duck", "goose"] 

7.Reflect.getOwnPropertyDescriptor(target, propertyKey)；

• target：需要寻找属性的目标对象。
• propertyKey：获取自己的属性描述符的属性的名称。

Reflect.getOwnPropertyDescriptor方法返回一个属性描述符，如果给定的属性存在于对象中，否则返回 undefined 。 与 Object.getOwnPropertyDescriptor() 的唯一不同在于如何处理非对象目标。

Reflect.getOwnPropertyDescriptor({ 
   x: "hello"}, "x"); // {value: "hello", writable: true, enumerable: true, configurable: true} Reflect.getOwnPropertyDescriptor({ 
   x: "hello"}, "y"); // undefined Reflect.getOwnPropertyDescriptor([], "length"); // {value: 0, writable: true, enumerable: false, configurable: false} Object.getOwnPropertyDescriptor() 的不同 Reflect.getOwnPropertyDescriptor("foo", 0); // TypeError: "foo" is not non-null object Object.getOwnPropertyDescriptor("foo", 0); // { value: "f", writable: false, enumerable: true, configurable: false } 

8.Reflect.getPrototypeOf(target)；

• target：获取原型的目标对象。

Reflect.getPrototypeOf 返回指定对象的原型 (即内部的 [[Prototype]] 属性的值) 。类似于 Object.getPrototypeOf()

Reflect.getPrototypeOf({ 
   }); // Object.prototype Reflect.getPrototypeOf(Object.prototype); // null Reflect.getPrototypeOf(Object.create(null)); // null 

9.Reflect.has(target, propertyKey)；

• target：目标对象.
• propertyKey：属性名，需要检查目标对象是否存在此属性。

判断一个对象是否存在某个属性，和 in 运算符 的功能完全相同。

Reflect.has({ 
   x: 0}, "x"); // true Reflect.has({ 
   x: 0}, "y"); // false // 如果该属性存在于原型链中，返回true  Reflect.has({ 
   x: 0}, "toString"); 

10.Reflect.isExtensible(target)

• target：检查是否可扩展的目标对象。

类似于 Object.isExtensible().

var empty = { 
   }; Reflect.isExtensible(empty); // === true  // ...but that can be changed.  Reflect.preventExtensions(empty); Reflect.isExtensible(empty); // === false  //与 Object.isExtensible() 的不同点 Reflect.isExtensible(1); // TypeError: 1 is not an object Object.isExtensible(1); // false 

11.Reflect.ownKeys(target)；

• target：获取自身属性键的目标对象。

返回一个包含所有自身属性（不包含继承属性）的数组。(类似于 Object.keys(), 但不会受enumerable影响).。它的返回值等同于Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))

Reflect.ownKeys({ 
   z: 3, y: 2, x: 1}); // [ "z", "y", "x" ] Reflect.ownKeys([]); // ["length"] 

12.Reflect.preventExtensions(target)；

• target：阻止扩展的目标对象。

类似于 Object.preventExtensions()。返回一个Boolean。

// Objects are extensible by default. var empty = { 
   }; Reflect.isExtensible(empty); // === true // ...but that can be changed. Reflect.preventExtensions(empty); Reflect.isExtensible(empty); // === false //*与 Object.preventExtensions() 的不同点 Reflect.preventExtensions(1); // TypeError: 1 is not an object Object.preventExtensions(1); // 1 

13.Reflect.setPrototypeOf(target, prototype)

• target：设置原型的目标对象。
• prototype：对象的新原型（一个对象或 null）。

设置对象原型的函数. 返回一个 Boolean， 如果更新成功，则返回true。

Reflect.setPrototypeOf({ 
   }, Object.prototype); // true // It can change an object's [[Prototype]] to null. Reflect.setPrototypeOf({ 
   }, null); // true // Returns false if target is not extensible. Reflect.setPrototypeOf(Object.freeze({ 
   }), null); // false // Returns false if it cause a prototype chain cycle. var target = { 
   }; var proto = Object.create(target); Reflect.setPrototypeOf(target, proto); // false 

Mozilla 开发者社区：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Reflect