[含泪吐血整理]Reflect对象中的13个静态函数

前言

小伙伴们大家好。前一篇文章中我们学习了ES6中新增的Reflect对象，了解了该对象的一些特点以及设计目的，最后还对该对象上的一些静态方法做了一个简单介绍。接下来将对这些方法进行一个展开分享。

Reflect.get(target, key, receiver)

Reflect.get()方法查找并返回target对象中的key属性，如果没有该属性则返回undefined，该与target[key]读取属性类似，但它是通过一个函数执行来操作的。

Reflect.get方法接收3个参数：

target：需要取值的目标对象

key：需要取值的目标对象的属性（键名）

receiver：如果目标对象target中指定了getter，则getters在调用时其内部的this将会指向receiver

方法返回值为目标对象中属性对应的值

如果target不是一个Object类型，则会报错

let obj = {
    
    
	x: 1,
	y: 2,
	get z(){
    
    
		return this.x + this.y
	}
}
Reflect.get(obj, 'x');// 1
Reflect.get(obj, 'y');// 2
Reflect.get(obj, 'z');// 3
Reflect.get(['one','two'],1);// two
Reflect.get(1, 'name');//报错
let newObj = {
    
    
	x: 5,
	y: 10
}

Reflect.get(obj, 'z', newObj);//15 obj中指定了getter，则getter中的this指向了第三个参数newObj

Reflect.set(target, key, value, receiver)

Reflect.set方法用于给目标对象的属性设置值，类似于target[key] = value。

Reflect.set方法接收4个参数：

target：要设置值的目标对象

key：目标对象中的属性名

value：要给属性设置的新值

receiver：如果目标对象的属性设置了setter，则setter中的this指向receiver

如果第一个target不是一个Object类型，则会报错

let obj = {
    
    
	x: 1,
	set y(value){
    
    
		return this.x = value
	}
}
console.log(obj.x);// 1
Reflect.set(obj, 'x', 10)
console.log(obj.x);// 10
Reflect.set(obj, 'y', 15);
console.log(obj.x);// 15
// =====================================
let obj = {
    
    
	x: 1,
	set y(value){
    
    
		return this.x = value
	}
}
let newObj = {
    
    
	x: 100
}
console.log(newObj.x); //100
Reflect.set(obj, 'x', 200, newObj);
console.log(obj.x);// 1
console.log(newObj.x) ;// 200

//=========================
Reflect.set(1, 'x', 10);// 报错

Reflect.has(target, key)

Reflect.has方法用来检测target对象中是否存在key属性，返回值为布尔类型，类似于key in target。

Reflect.has方法接收2个参数：

target：要检测的目标对象

key：要检测的属性名

如果第一个参数target不是object类型则报错

let obj = {
    
    
	name: 'Yannis'
}
'name' in obj;// true
Reflect.has(obj, 'name');// true

Reflect.deleteProperty(target, key)

Reflect.deleteProperty方法用于删除目标对象target中的属性key，相当于delete target[key]。

Reflect.deleteProperty方法接收2个参数：

target：要删除属性的目标对象

key：要删除的目标属性

该方法返回一个布尔类型值，如果删除成功或者删除的属性不存在则返回true，删除失败则返回false

如果第一个参数target不是object类型，则会报错

let obj = {
    
    
	name: 'Yannis',
	age: 28
}

//delete obj.name
delete obj['name']; // true
Reflect.deleteProperty(obj, 'name');// true
Reflect.deleteProperty(obj, 'age');// true
Reflect.deleteProperty(obj, 'aaa');// true

Reflect.construct(target, args)

Reflect.construct方法等同于new target(…args)。该方法可以不使用new来实现构造函数的调用

Reflect.construct接收两个参数

target：是一个函数类型，否则会报错

args：是一个数组，否则会报错

function Greeting(name){
    
    
	this.name = name
}
let g = new Greeting('Yannis');
g.name;// Yannis

let g2 = Reflect.construct(Greeting, ['Alvin'])
g2.name;// Alvin

Reflect.getPrototypeOf(target)

Reflect.getPrototypeOf方法用于获取对象的__proto__属性，与Object.getPrototypeOf功能是一样的。但二者的区别是：如果参数target不是一个对象Reflect.getPrototypeOf会直接报错，而Object.getPrototypeOf则是先转换为对象然后再操作

let obj = {
    
    }
Object.getPrototypeOf(obj) === Object.prototype; // true
Reflect.getPrototypeOf(obj) === Object.prototype; // true
Object.getPrototypeOf(1) // Number {[[PrimitiveValue]]: 0}
Reflect.getPrototypeOf(1) // 报错

Reflect.setPrototypeOf(target, newProto)

该方法用于设置目标对象的原型，相当于Object.setPrototypeOf(targe, newObj)。

该方法接收2个参数：

target：要设置新原型的目标对象

newProto：新原型的值

如果第一个参数不是对象，Object.setPrototypeOf会返回对象本身而Reflect.setPrototypeOf则直接报错

如果第一个参数是Undefined或null则二者都会报错

let obj = {
    
    }
Object.setPrototypeOf(obj, Array.prototype);
Reflect.setPrototypeOf(obj,Array.prototype); 

Object.setPrototypeOf(1, {
    
    })  // 1
Reflect.setPrototypeOf(1, {
    
    })
// TypeError: Reflect.setPrototypeOf called on non-object

Object.setPrototypeOf(undefined, {
    
    })  // 报错
Reflect.setPrototypeOf(undefined, {
    
    }) // 报错

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了，这个方法用起来显得太麻烦，如果使用Reflect.apply代替则会使代码更简洁易懂。

Reflect.apply方法接收3个参数：

func：目标函数

thisArg：func函数调用时绑定的this对象

args：func调用时传入的参数列表，该参数是一个类数组对象

let obj = [1,3,8,20,55,100]
Math.min.apply(Math, obj); // 1
Reflect.apply(Math.min, Math, obj); // 1

Reflect.defineProperty(target, key, attributes)

Reflect.defineProperty相当于Object.defineProperty是用来给对象定义属性的。Reflect.defineProperty将慢慢替换掉Object.defineProperty

Reflect.defineProperty接收3个参数：

target：目标对象

key：要定义的属性

attributes：要定义或修改的属性的描述

let obj = {
    
    };
Object.defineProperty(obj,'name' {
    
    
	value: 'Yannis'
});

Reflect.defineProperty(obj, 'age', {
    
    
	value: 28
});
obj.name;// Yannis
obj.age; // 28

Reflect.ownKeys(target)

Reflect.ownKeys方法用于返回对象的所有属性，相当于Object.getOwnPropertyNames和Object.getOwnPropertySymbols之和

Reflect.ownKeys只接收一个参数：target目标对象

let obj  = {
    
    
	name: 'Yannis',
	age: 28,
	[Symbol.for('x')]: 1,
	[Symbol.for('y')]: 2
}

Object.getOwnPropertyNames(obj); // ['name','age']
Object.getOwnPropertySymbols(obj); // ['x','y']
Reflect.ownKeys(obj);//['name','age', 'x','y']

Reflect.getOwnPropertyDescriptor(target, key)

Reflect.getOwnPropertyDescriptor方法用于获取目标对象给定属性的描述，相当于Object.getOwnPropertyDescriptor。

接收两个参数：目标对象和要获取描述的属性

let obj = {
    
    }
Object.defineProperty(obj, 'name', {
    
    
	value: true,
	enumerable: false
}
Object.getOwnPropertyDescriptor(obj, 'name');
Reflect.getOwnPropertyDescriptor(obj, 'name');

Reflect.isExtensible(target)

Reflect.isExtensible方法用于标识目标对象是否可扩展，等同于Object.isExtensible(target)，返回值为布尔类型

Reflect.isExtensible方法接收一个参数target：目标对象

如果target不是对象，则Reflect.isExtensible会报错而Object.isExtensible返回false

let obj = {
    
    };
Object.isExtensible(obj); // true
Reflect.isExtensible(obj); // true
Object.isExtensible(1); // false
Reflect.isExtensible(1); // 报错

Reflect.preventExtensions(target)

Reflect.preventExtensions方法用于设置目标对象不可扩展，等同于Object.preventExtensions，返回值为布尔类型

Reflect.preventExtensions方法接收一个参数target：目标对象

let obj = {
    
    }
Reflect.isExtensible(obj);// true
Object.preventExtensions(obj);
Reflect.preventExtensions(obj);
Reflect.isExtensible(obj);// false

总结

本篇文章中对Reflect对象中的13个静态方法进行了扩展分享，让我们更进一步的了解了Reflect的使用及用途。关于方法的分享就到这里了。

喜欢的小伙伴欢迎点赞留言加关注哦！

[含泪吐血整理]Reflect对象中的13个静态函数

前言

Reflect.get(target, key, receiver)

Reflect.set(target, key, value, receiver)

Reflect.has(target, key)

Reflect.deleteProperty(target, key)

Reflect.construct(target, args)

Reflect.getPrototypeOf(target)

Reflect.setPrototypeOf(target, newProto)

Reflect.apply(func, thisArg, args)

Reflect.defineProperty(target, key, attributes)

Reflect.ownKeys(target)

Reflect.getOwnPropertyDescriptor(target, key)

Reflect.isExtensible(target)

Reflect.preventExtensions(target)

总结

Guess you like