ES6个人笔记记录——Reflect2

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