Reflect 对象和 Proxy 对象一样，是对对象的操作，但是 Reflect 有以下几点优势。

修改了 Object 方法的返回结果。Object 对象的一些操作返回错误时，而Reflect 返回 false。
让 Object 的操作变成函数。
Reflect 对象的方法和 Proxy 对象的方法一一对应。

这一章可以对照的 Proxy 的内容一起看。Proxy

Reflect.get(target,name,receiver)
查找并返回 target 对象的 name 属性，如果没有找到该属性，则返回undefined。
Reflect.set(target,name,value,receiver)
设置 target 对象的 name 属性等于 value 。
Reflect.has(obj,name)
对应 name in obj 中的 in 运算符。
Reflect.deleteProperty(obj,name)
用于删除对象的属性，相当于 delete obj[name] 。
Reflect.construct(target,args)
等同于调用了 new target(…args)，提供了一种不适用 new 来调用构造函数的方法。
Reflect.getPrototypeOf(obj)
读取对象的 __proto__ 属性，对应 Object.getPrototypeOf(obj)。
Reflect.setPrototypeOf(obj,newProto)
设置对象的 __proto__ 属性，返回第一个参数对象，对应 Object.setPrototypeOf(obj,newProto)。
Reflect.apply(func,thisArg,args)
等同于Function.prototype.apply.call(func,thisArg,args)，用于绑定 this 对象后执行给定的函数。
Reflect.defineProperty(target,propertyKey,attributes)
等同于 Object.defineProperty()，用来为对象定义属性。
Reflect.getOwnPropertyDescriptor(target,propertyKey)
等同于 Object.getOwnPropertyDescriptor，用于获得指定属性的描述对象。
Reflect.isExtensible(target)
对应 Object.isExtensible，返回一个布尔值，表示当前对象是否可以扩展。
Reflect.preventExtensions(target)
对应 Object.preventExtensions，用于使一个对象变为不可扩展的，返回一个布尔值，表示是否操作成功。
Reflect.ownKeys(target)
等同于 Object.getOwnPropertyNames 和 Object.getOwnPropertySymbols 之和，用于返回对象的所有属性。

2004-2-29 星期日(Sunday) 晴

可以利用reflect取出类的信息，并可以执行类的方法使用类的属性，也可以为类添加方法和属性，也可以再classloader对字节码类进行处理。

概述
Reflect对象和Proxy对象一样，也是ES6为了操作对象而提供的API
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)让他们变成了函数行为)
	
4.Reflect对象的方法与Proxy对象的方法一一对应，只要是Proxy对象的方法， 、就能在Reflect对象上找到对应的方法。这就使Proxy对象可以方便地调用对应的Reflect方法来完成默认行为，作为修改行为的基础。也就是说，无论Proxy怎么修改默认行为，我们总可以在Reflect上获取默认行为

1和2条的例子
// 旧写法
try{
	Object.defineProperty(target,property,attributes);
		// success
} catch(e){
		// failure
}


// 新写法
if(Reflect.defineProperty(target,property,attributes)){
	// success
}else{
	// failure
}

3条的例子
// 旧写法
console.log('assign' in Object);

// 新写法
console.log(Reflect.has(Object,'assign'));

4条的例子
const { 
	set ,
	get ,
	deleteProperty ,
	has
} = Reflect;

Proxy(target,{
	set : function(target,name,value,receiver){
		let success = set(target,name,value,receiver);
		if(success){
			log('property ' + name + ' on ' + target + ' set to ' + value);
		}
		return success;
	}
})

代码中，Proxy方法拦截target对象的属性赋值行为。
它采用Reflect.set方法将值赋给对象的属性，确保完成原有的行为，然后再部署额外的功能
let loggedObj = new Proxy(obj,{
	get(target,name){
		console.log('get',target,name);
		return get(target,name);
	},
	deleteProperty(target,name){
		console.log('delete',name);
		return deleteProperty(target,name);
	},
	has(target,name){
		console.log('has',name);
		return has(target,name);
	}
})

上面的代码中，m每一个Proxy对象的拦截操作(get,delete,has)内部都调用对应的Reflect方法，保证原生行为能正常运行，添加的工作就是将每一个操作输出一个日志
有了Reflect对象，很多操作更易读
// 旧写法
console.log(Function.prototype.apply.call(Math.floor,undefined,[1,75]));

// 新写法
console.log(Reflect.apply(Math.floor,undefined,[1,75]));

1.Reflect.get()
Reflact.get 方法查找并返回target对象的name属性，
如果没有该属性，则返回undefined

const { 
	get , 
	set , 
	defineProperty ,
	deleteProperty ,
	construct ,
	getPrototypeOf ,

} = Reflect;

let myObject1 = {
	foo : 1,
	bar : 2,
	get baz(){
		return this.foo + this.bar;
	}
};

console.log(get(myObject1, 'foo'),
	get(myObject1, 'bar'),
	get(myObject1, 'baz'));

let myReceiverObject = {
	foo : 4,
	bar : 4,
};

如果name属性部署了读取函数(getter)，则读取函数的this绑定receiver
如果第一个参数不是对象就会报错
console.log(get(myObject1,'baz',myReceiverObject));

2.Reflect.set(target,name,value,receiver)
用Reflect.set方法设置target对象的name属性等于value
let myObject2 = {
	foo : 1,
	set bar(value){
		return this.foo = value;
	}
}

console.log(myObject2.foo);
set(myObject2,'foo',2);
console.log(myObject2.foo);
set(myObject2,'bar',10);
console.log(myObject2.foo);

如果name属性设置了赋值函数，则赋值函数的this绑定receiver
let myReceiverObject1 = {
	foo : 0,
};

set(myObject2,'bar',1,myReceiverObject1);
console.log(myObject2.foo,myReceiverObject1.foo);

如果第一个参数不是参数，Reflect.set()会报错
注意：Reflect.set会触发Proxy.defineProperty
let p = {
	a : 'a'
};

let handler = {
	set(target,key,value,receiver){
		console.log('set');
		set(target,key,value,receiver);
	},
	defineProperty(target,key,attribute){
		console.log('defineProperty');
		defineProperty(target,key,attribute);
	}
};

let obj = new Proxy(p,handler);
obj.a = 'A';

3.Reflect.deleteProperty(obj,name)
Reflect.deleteProperty方法等同于delete obj[name]，用于删除对象的属性。
const myObj = { foo : 'bar' };

// 旧写法
console.log(delete myObj.foo);

// 新写法
console.log(deleteProperty(myObj,'foo'));

 该方法返回一个布尔值。
 如果删除成功或者被删除的属性不存在，就返回true；
 如果删除失败或者被删除的属性依然存在，就返回false

4.Reflect.construct(target,args)
Reflect.construct方法等同于new target(...args),
提供了一种不使用new来调用构造函数的方法

function Greeting(name){
	this.name = name;
}

// new的写法
const instance = new Greeting("wjy");

// Reflect.construct的写法
const instanceNew = construct(Greeting,["hj"]);

5.Reflect.getPrototypeOf(obj)
用于读取对象的__proto__属性,对应Object.getPrototypeOf(obj)
const myObj3 = new FancyThing();

// 旧写法
Object.getPrototypeOf(myObj3) === FancyThing.prototype;

// 新写法
getPrototypeOf(myObj3) === FancyThing.prototype;

// 区别:
// 如果参数不是对象,Object.getPrototypeOf会将这个参数转为对象,然后再运行
// 而Reflect.getPrototypeOf会报错

// eg
Object.getPrototypeOf(1)	//Number{[[PrimitiveValue]] : 0}
Reflect.getPrototypeOf(1)	//报错

6.Reflect.setPrototypeOf(obj,newProto)
Reflect.setPrototypeOf方法用于设置对象的__proto__属性,返回第一个参数对象,对应Object.setPrototypeOf(obj,newProto)
7. Reflect.apply(func,thisArg,args)
Reflect.apply方法等同于Function.prototype.apply.call(func,thisArg,args)
用于绑定this对象后执行给定函数
一般来说,如果要绑定一个函数的this对象,可以写成fn.apply(obj,args)的形式,但是如果函数定义了自己的apply方法,那么就只能写成Function.prototype.apply.call(fn,obj,args)的形式,采用Reflect对象可以简化这种操作.

const args = [11,33,12,54,18,96];

// 旧写法
const youngest = Math.min.apply(Math,args);
const oldest = Math.max.apply(Math,args);
const type = Object.prototype.toString.call(youngest);

// 新写法
const youngest_1 = Reflect.apply(Math.min,Math,args);
const oldest_1 = Reflect.apply(Math.max,Math,args);
const type_1 = Reflect.apply(Object.prototype.toString,youngest,[]);

8.Reflect.defineProperty(target,propertyKey,attributes)
方法基本等同于Object.defineProperty,用来定义对象属性
/*
	function MyDate(){
		//
	}
	
// 旧写法
Object.defineProperty(MyDate,'now',{
	value : () => Date.now();
});

// 新写法
Reflect.defineProperty(MyDate,'now',{
	value : () => Date.now();
});

	如果Reflect.defineProperty的第一个参数不是对象,就会抛出错误.
	比如Reflect.defineProperty(1,'foo')
 */

9.Reflect.getOwnPropetyDescriptor(target,propertyKey)
用于获得指定属性的描述对象
10.Reflect.isExtensible(target)
表示当前对象是否可拓展
11.Reflect.perventExtensions(target)
用于使一个对象变为不可扩展,返回一个布尔值,表示操作是否成功
12.Reflect.ownKey(target)
用于返回对象的所有属性,基本等同于:Object.getOwnPropertynames()和Object.getOwnPropertySymbols之和
// eg
let myObj4 = {
	foo : 1,
	bar : 2,
	[Symbol.for('baz')] : 3,
	[Symbol.for('bing')] : 4,
};

// 旧写法
console.log(Object.getOwnPropertySymbols(myObj4),
	Object.getOwnPropertyNames(myObj4));

// 新写法
console.log(Reflect.ownKeys(myObj4));