含义
Reflect是一个内置对象，它提供拦截javascript操作的方法。它不是一个函数，因此是不可构造的。
作为一个函数来调用。Reflect的所有属性和方法都是静态的（和Math比较像）。
静态方法
Reflect.apply(target, thisArggument, argumentsList)
参数：
target: 目标函数thisArgument: target调用函数是绑定的this对象argumentsList: target函数调用是传入的实参列表，数组 或 类数组
返回值
函数的返回结果
异常
如果target对象不可用，抛出TypeError
总结
该方法与ES5中的Function.prototype.apply()方法类似，调用一个方法并显示地指定this变量和参数列表。
使用
Reflect.apply(Math.floor, undefined, [1.75]); // 1
Reflect.apply(Math.fromCharCode, undefined, [104, 101, 108, 108, 111]); // 'hello'
Reflect.apply(RegExp.prototype.exec, /ab/, ['confabulation']).index; // 4
Reflect.apply(''.chaAt, 'ponies', [3]); // 'i';
Reflect.apply('', 'ponies', [3]); // 抛出TypeError
Reflect.construct(target, argumentsList[, newTarget])
参数：
target: 目标函数argumentsList: 类数组，目标构造函数调用时的参数newTarget可选: 作为新创建对象的constructor属性，默认值为target
返回值
实例化后的对象
异常
如果target 或者 newTarget不是构造函数，抛出TypeError异常
总结
Reflect.construct方法的行为有点像new操作符，相当于运行new target(...args)
使用
const obj1 = new Foo(...args);
const obj2 = Reflect.construct(Foo, args);
Reflect.construct() VS Object.create()
function One() {
this.name = 'one';
}
function Two() {
this.name = 'two';
}
const obj1 = Reflect.construct(One, [], Two);
// 等效
const obj2 = Object.create(Two.prototype);
One.apply(obj2);
console.log(obj1.name); // one
console.log(obj2.name); // one
console.log(obj1 instanceof One); // false
console.log(obj2 instanceof One); // false
console.log(obj1 instanceof Two); // true
console.log(obj2 instanceof Two); // true
Reflect.defineProperty(target, propertyKey, attributes)
参数：
target: 目标对象propertyKey: 要定义或者要修改的属性名称attributes: 要定义或者要修改的属性的描述
返回值
Boolean值，表示属性是否被成功定义
异常
如果target不是Object，会出一个TypeError
总结
和Object.defineProperty()类似，设置成功会返回true。但是Object.defineProperty()返回值为一个对象。
使用
const obj = {};
Reflect.defineProperty(obj, 'x', {value: 7});
obj.x // 7
Reflect.deleteProperty(target, propertyKey)
参数：
. target: 目标函数
. propertyKey: 需要删除的key
返回值
Boolean值表示该属性是否被成功删除
异常
如果target不是Object，抛出TypeError
总结
该方法几乎允许我们删除一个对象上的属性，返回一个Boolean值表示改属性是否被删除成功。它几乎与非严格的delete、operator相同
使用
const obj = {x: 1, y: 2};
Reflect.deleteProperty(obj, 'x'); // true
obj; // {y: 2}
Reflect.get(target, propertyKey[, receiver])
参数：
. target: 需要取值的目标对象
. propertyKey: 需要回去值的键
. receiver 可选: 如果target对象制定了getter，receiver则为getter调用是的this的值
返回值
属性的值
异常
如果目标类型性不是Object，则抛出TypeError
总结
该方法允许我们从一个对象汇总取属性值。就如同属性访问器语法，但却是通过函数调用来实现。
使用
const obj = {x: 1, y: 2};
Reflect.get(obj, 'x'); // 1
Reflect.get(['zero', 'one'], 1); // 'one'
// Proxy
vat x = {p: 1};
var obj = new Proxy(x, {
get(t, g, r) {
return { return k + 'bar'}
}
});
Reflect.get(obj, 'foo'); // 'foobar'
Reflect.getOwnPropertyDescriptor(target, propertyKey)
参数：
. target: 需要寻找属性的目标对象
. propertyKey: 获取自己的属性描述符的属性的名称
返回值
如果属性存在给定的目标对象中，则返回属性描述符；否则，返回undefined
异常
如果target不是Object，抛出TypeError
总结
该方法返回一个属性描述符。与Object.getOwnPropertyDescriptor()类似。两者唯一不同在于如何处理非对象目标
使用
const obj = {x: 'hello'};
Reflect.getOwnPropertyDescriptor(obj, 'x');
// {value: 'hello', writable: true, enumerable: true, configurable: true}
Reflect.getOwnPropertyDescriptor(obj, 'y');
// undefined
Reflect.getOwnPropertyDescriptor('foo', 0);
// TYpeError: 'foo' is not non-null object
Object.getOwnPropertyDesciptor('foo', 0);
// {value: 'f', writable: false, enumerable: true, configurable: false}
Reflect.getPrototypeOf(target)
参数：
. target: 获取原型的目标对象
返回值
给定对象的原型。如果给定对象没有继承的属性，则返回null。
异常
如果target不是Object，抛出TypeError
总结
返回给定对象的原型（即内部的[[prototype]]属性的值）
使用
Reflect.getPrototypeOf({}); // Object.prototype
Reflect.getPrototypeOf(Object.prototype); // null
Reflect.getPrototypeOf(Object.create(null)); // null
Reflect.has(target, propertyKey)
参数：
. target: 目标对象
. propertyKey: 属性名
返回值
Boolean类型的对象知识是否存在改属性
异常
如果Target不是Object，抛出TypeError
总结
检查一个对象是拥有某个属性，相当于 in操作符
使用
const obj = {x: 1};
Reflect.has(obj, 'x'); // true
Reflect.has(obj, 'y'); // false
// Proxy
const p = new Proxt({}, {
has(t, k) {
return k.startsWith('door');
}
})
Reflect.has(p, 'doorbell'); // true
Reflect.has(p, 'dormitory'); // false
Reflect.isExtensible(target)
参数：
. target: 检查是否可扩展目标对象
返回值
Boolean值表示对象是否可以扩展
异常
如果target不是Object，抛出TypeError
总结
该方法判断一个对象是否可扩展（即是否能够添加新的属性），它与Object.isExtensible()方法几乎一样，不同处在Object.isExtensible()在target如果是原始值时，会强制把target转换为一个对象。
使用
let empty = {};
Reflect.isExtensible(empty); // true
Reflect.preventExtensive(empty);
Reflect.isExtensible(empty); // false
let sealed = Object.seal({});
Reflect.isExtensible(sealed); // false
let frozen = Object.freeze({});
Reflect.isExtensible(frozen); // false
Reflect.ownKeys(target)
参数：
. target: 获取自身性键的目标对象。
返回值
由目标对象的自身属性键组成的数组
异常
如果target不是Object，抛出TypeError
总结
它的返回值等于Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target)).
使用
Reflect.ownKeys({x: 1, y: 2}); // [x, y]
Reflect.ownKeys([]); // ['length']
let obj = {
[Symbol.for('comet')]: 1,
[Symbol.for('meteor')]: 2,
'0': 0
str: 'strvalue'
}
Reflect.ownKeys(obj);
// ['0', 'str', [Symbol.for('comet')], [Symbol.for('meteor')]]
Reflect.preventExtensions(target)
参数：
. target: 阻止扩展的目标对象
返回值
返回一个boolean
异常
如果target不是对象，则抛出TypeError
总结
该方法组织新属性添加到对象。与Object.preventExtensions方法相似。不同处在于如果Object.preventExtensions的target不是对象，会被强制转换为对象。
使用
let empty = {};
Reflect.isExtensible(empty); // true
Reflect.preventExtensions(empty); // true
Reflect.isExtensible(empty); // false
Reflect.set(target, propertyKey, value[, receiver])
参数：
. target: 设置该属性的目标对象
. propertyKey: 设置的属性的名称
. value: 设置属性的值
. receiver 可选： 如果遇到setter，receiver则为setter调用是的this的值
返回值
Boolean表示是否成功设置改属性
异常
如果Target不是对象，抛出TypeError
总结
它的作用是给属性复制并且像property accessor语法一样，但是他是函数的方式
使用
let obj = {};
Reflect.set(obj, 'x', 1); // true
obj.x // 1
let arr = ['zero', 'one', 'two'];
Reflect.set(arr, 2, 'two-2'); // true
arr[2]; // 'two-2'
Reflect.set(arr, 'length', 1);
arr; // ['zero']
let obj2 = {};
Reflect.set(obj2); // true
Reflect.getOwnPropertyDescriptor(obj2, 'undefined');
// {value: undefined, writable: true, enumerable: true, configuable: true}
Reflect.setPrototype(target, prototype)
参数：
. target: 设置原型的目标对象
. prototype: 对象的新原型（一个对象 或null）
返回值
Boolean值，表示是否设置成功。
异常
如果target不是Object，或者prototype既不是对象也不是null。抛出TypeError
总结
该方法改变对象的原型（即，内部[[Prototype]]属性值）
使用
Reflect.setPrototypeOf({}, Object.prototype); // true
Reflect.setPrototypeOf({}, null) // true
Reflect.setPrototype(Object.freeze({}), null) // false
let target = {};
var proto = Object.create(target);
Reflec.setPrototype(target, proto); // false
