JS中反射Reflect的基本使⽤
⽂章⽬录
⼀、概述
Reflect 对象的设计⽬的有这样⼏个。
（1） 将 Object 对象的⼀些明显属于语⾔内部的⽅法（⽐如 Object.defineProperty ），放到 Reflect 对象上。现阶段，某些⽅法同时在Object 和 Reflect 对象上部署，未来的新⽅法将只部署在 Reflect 对象上。也就是说，从 Reflect 对象上可以拿到语⾔内部的⽅法。
（2）修改某些 Object ⽅法的返回结果，让其变得更合理。⽐如，Object.defineProperty(obj, name, desc) 在⽆法定义属性时，会抛出⼀个错误，定义成功时返回修改后的对象。⽽ Reflect.defineProperty(obj, name, desc) 在定义属性成功时返回 true ，失败时返回 fal。
// ⽼写法
try{
Object.defineProperty(target, property, attributes);
// success
}catch(e){
// failure
}
// 新写法
if(Reflect.defineProperty(target, property, attributes)){
// success
}el{
// failure
}
（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 上获取默认⾏为。
var loggedObj =new Proxy(obj,{
get(target, name){
console.log('get', target, name);
(target, name);
},
deleteProperty(target, name){
console.log('delete'+ name);
return Reflect.deleteProperty(target, name);
},
has(target, name){
小学生交通安全知识console.log('has'+ name);2016年11月19日
return Reflect.has(target, name);
}
});
⼆、静态⽅法
pitched
Reflect 对象⼀共有 13 个静态⽅法。
Reflect.apply(target, thisArg, args)
<(target, name, receiver)
Reflect.t(target, name, value, receiver)
Reflect.defineProperty(target, name, desc)
Reflect.deleteProperty(target, name)
Reflect.has(target, name)
Reflect.ownKeys(target)
Reflect.isExtensible(target)
Reflect.preventExtensions(target)
Reflect.tPrototypeOf(target, prototype)
上⾯这些⽅法的作⽤，⼤部分与 Object 对象的同名⽅法的作⽤都是相同的，⽽且它与 Proxy 对象的⽅法是⼀ ⼀对应的。
1、(target, name, receiver)
< ⽅法查找并返回 target 对象的 name 属性，如果没有该属性，则返回 undefined。
let obj ={
name:'webchang',
age:18,
along
get info(){
return this.name +' '+this.age;
}
饮食习惯 英语}
console.(obj,'name'));// webchang
console.(obj,'age'));// 18
console.(obj,'info'));// webchang 18
如果 (target, name, receiver) 的第⼆个参数属性部署了读取函数（getter）:
没有第三个参数，this 绑定当前对象
有第三个参数，读取函数的 this 绑定到第三个参数 receiver 上。
let obj ={
name:'webchang',
whileage:18,
get info(){
return this.name +' '+this.age;
}
}
let obj2 ={
name:'张三',
age:40
}
console.(obj,'info', obj2));// 张三 40
target 对象也可以是数组：
<([1,2,3],1)// 输出索引 1 对应的值：2
如果第⼀个参数不是对象， ⽅法会报错。
<(1,'foo')// 报错 TypeError: called on non-object
<(fal,'foo')// 报错
全国研究生网上报名系统2、Reflect.t(target, name, value, receiver)
Reflect.t ⽅法设置 target 对象的 name 属性等于 value。
let obj ={
name:'webchang',
t age(value){
this._age = value;
}
}
console.log(obj.name);// webchang
Reflect.t(obj,'name','李四');
console.log(obj.name);// 李四
Reflect.t(obj,'age',18);
console.log(obj._age);// 18
3、Reflect.has(obj, name)
Reflect.has ⽅法对应 name in obj ⾥⾯的 in 运算符。如果 Reflect.has() ⽅法的第⼀个参数不是对象，会报错。
var myObject ={
foo:1,
};
// 旧写法
'foo'in myObject // true
// 新写法
Reflect.has(myObject,'foo')// true
4、Reflect.deleteProperty(obj, name)
Reflect.deleteProperty ⽅法等同于 delete obj[name]，⽤于删除对象的属性。该⽅法返回⼀个布尔值。如果删除成功，或者被删除的属性不存在，返回true；删除失败，被删除的属性依然存在，返回fal。
如果 Reflect.deleteProperty() ⽅法的第⼀个参数不是对象，会报错。
const myObj ={ foo:'bar'};
// 旧写法
delete myObj.foo;
// 新写法
Reflect.deleteProperty(myObj,'foo');
5、struct(target, args)
function Person(name, age){
this.name = name;
this.age = age;
}
// new 的写法
let p1 =new Person('webchang',18);
// struct 的写法，两种写法最终效果⼀样
let p2 = struct(Person,['webchang',18]);
6、PrototypeOf(obj)
韩语班培训
function Person(){}
let p =new Person();
console.PrototypeOf(p)=== Person.prototype);// true
console.PrototypeOf(p)=== Person.prototype);// true
如果参数不是对象，PrototypeOf 会将这个参数转为对象，然后再运⾏，⽽PrototypeOf 会报错。
7、Reflect.tPrototypeOf(obj, newProto)
Reflect.tPrototypeOf ⽅法⽤于设置⽬标对象的原型（prototype），对应 Object.tPrototypeOf(obj, newProto) ⽅法。它返回⼀个布尔值，表⽰是否设置成功。
paud
let obj ={
name:'webchang'
}
// 旧写法，设置成功会返回修改后的对象
Object.tPrototypeOf(obj, Array.prototype);
// 新写法，设置成功会返回 true
Reflect.tPrototypeOf(obj, Array.prototype);
如果第⼀个参数不是对象，Object.tPrototypeOf 会返回第⼀个参数本⾝，⽽ Reflect.tPrototypeOf 会报错。
Object.tPrototypeOf(1,{})
// 1
Reflect.tPrototypeOf(1,{})
// TypeError: Reflect.tPrototypeOf called on non-object
如果第⼀个参数是 undefined 或 null ，Object.tPrototypeOf 和 Reflect.tPrototypeOf 都会报错。
Object.tPrototypeOf(null,{})
// TypeError: Object.tPrototypeOf called on null or undefined
Reflect.tPrototypeOf(null,{})
// TypeError: Reflect.tPrototypeOf called on non-object
偶尔8、Reflect.apply(func, thisArg, args)
第⼀个参数是函数，第⼆个参数⽤来指定 this 的指向，第三个参数是数组。
⼀般来说，如果要绑定⼀个函数的 this 对象，可以这样写 fn.apply(obj, args)，但是如果函数定义了⾃⼰的 apply ⽅法，就只能写成Function.prototype.apply.call(fn, obj, args) ，采⽤ Reflect 对象可以简化这种操作。
const ages =[11,33,12,54,18,96];
// 旧写法
const youngest = Math.min.apply(Math, ages);
const oldest = Math.max.apply(Math, ages);
// 新写法
const youngest = Reflect.apply(Math.min, Math, ages);
const oldest = Reflect.apply(Math.max, Math, ages);
9、Reflect.defineProperty(target, propertyKey, attributes)
Reflect.defineProperty ⽅法基本等同于 Object.defineProperty，⽤来为对象定义属性。
function MyDate(){
/*…*/
}
/
/ 旧写法
Object.defineProperty(MyDate,'now',{
value:()=> w()
});
// 新写法
Reflect.defineProperty(MyDate,'now',{
value:()=> w()
});
10、OwnPropertyDescriptor(target, propertyKey)
let obj ={
name:'webchang'
}
console.OwnPropertyDescriptor(obj,'name'));
console.OwnPropertyDescriptor(obj,'name'));
如果第⼀个参数不是对象，OwnPropertyDescriptor(1, 'foo') 不报错，返回 undefined，⽽OwnPropertyDescriptor(1, 'foo') 会抛出错误，表⽰参数⾮法。
11、Reflect.isExtensible (target)
Reflect.isExtensible ⽅法对应 Object.isExtensible，返回⼀个布尔值，表⽰当前对象是否可扩展。
let obj ={}
// 旧写法
Object.isExtensible(obj);// true
// 新写法
Reflect.isExtensible(obj);// true
Object.freeze(obj);
Reflect.isExtensible(obj);// fal
如果参数不是对象，Object.isExtensible 会返回 fal，因为⾮对象本来就是不可扩展的，⽽ Reflect.isExtensible 会报错。
Object.isExtensible(1)// fal
Reflect.isExtensible(1)// TypeError: Reflect.isExtensible called on non-object
