ES6之Reflect

· 2021-07-30 17:18:14 · # ES6

Reflect是ES6新增的一个内置对象，它提供的方法和Proxy的实例方法是一致的，可以让你在使用Proxy时能够方便的获取原始方法。Reflect中的一些方法和Object的原型链上的方法同名

既然已经有现成的方法了，为什么还要重复造概念？

Reflect被造出来的一个主要原因是现状下没有一个能获取到所有语言内部方法的内置对象。很对的内部方法被设计到了其他的内置对象上。如Object.definedProperty、Object.defineProperties
目前某些内部方法的返回结果不符合预期。具体差异见MDN文章比较 Reflect 和 Object 方法
Reflect提供的方法和Proxy的实例方法是一致的, 能在Proxy实例上找到的方法，Reflect上一定能找到。当你使用Proxy拦截或修改程序默认行为的时候，可以很方便的在Reflect上面找到原始的方法，这让你有更大的发挥空间。

Reflect.apply(target, thisArgument, argumentsList)

对一个函数进行调用操作，同时可以传入一个数组作为调用参数。和 Function.prototype.apply() 功能类似。

function fn() {}

// function
fn.apply(this, [1,2, 3])

// Relfect
Reflect.apply(fn, this, [1, 2, 3])

Reflect.construct(target, argumentsList[, newTarget])

对构造函数进行 new 操作，相当于执行 new target(...args)。

function fn() {}

// function
const instance = new fn([1, 2, 3])

// Relfect
Reflect.construct(fn, [1, 2, 3])

Reflect.defineProperty(target, propertyKey, attributes)

和 Object.defineProperty() 类似。如果设置成功就会返回 true

const obj = {}
// Object 实现
Object.defineProperty(
  obj,
  'key', 
  { value: 'number' } 
)

// Reflect实现
Reflect.defineProperty(
  obj,
  'key', 
  { value: 'number' } 
)

Reflect.deleteProperty(target, propertyKey)

作为函数的delete操作符，相当于执行 delete target[name]。

const obj = {a: 1}

// before
delete obj['a']

// after
Reflect.deleteProperty(obj, 'a')

Reflect.get(target, propertyKey[, receiver])

获取对象身上某个属性的值，类似于 target[name]。

const obj = {a: 1}

// before
obj['a']

// after
Reflect.deleteProperty(obj, 'a')

Reflect.getOwnPropertyDescriptor(target, propertyKey)

类似于 Object.getOwnPropertyDescriptor()。如果对象中存在该属性，则返回对应的属性描述符, 否则返回 undefined.

const obj = {a: 1}

// before
Object.getOwnPropertyDescriptor(obj, 'a') 
// output: {value: 1, writable: true, enumerable: true, configurable: true}

// after
Reflect.getOwnPropertyDescriptor(obj, 'a')
// output: {value: 1, writable: true, enumerable: true, configurable: true}

Reflect.getPrototypeOf(target)

类似于 Object.getPrototypeOf()。

// before
const prototype1 = {};
const object1 = Object.create(prototype1);

console.log(Object.getPrototypeOf(object1) === prototype1);
// output: true

// after
Reflect.getPrototypeOf(prototype1)
// output: prototype1的原型

Reflect.has(target, propertyKey)

判断一个对象是否存在某个属性，和 in 运算符的功能完全相同。

const obj = {a: 1}
// before
console.log('a' in obj) // true

// after
Reflect.has(obj, 'a')

Reflect.isExtensible(target)

类似于 Object.isExtensible()判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。

// Object
Object.isExtensible({}) // true
Object.isExtensible(1) // false
Object.isExtensible('') // false

// Reflect
Reflect.isExtensible({}) // true
Reflect.isExtensible(1) // false
Reflect.isExtensible('') // false

Reflect.ownKeys(target)

返回一个包含所有自身属性（不包含继承属性）的数组。(类似于 Object.keys(), 但不会受enumerable影响).

const obj = {aa: 22}

console.log(Object.keys(obj))
// output: ['aa']

console.log(Reflect.ownKeys(obj))
// output: ['aa']

Reflect.preventExtensions(target)

类似于 Object.preventExtensions()。返回一个Boolean。

Reflect.set(target, propertyKey, value[, receiver])

将值分配给属性的函数。返回一个Boolean，如果更新成功，则返回true。

const obj = {}
Reflect.set(obj, 'aa', '22')

console.log(obj)
// output: {aa: 22}

Reflect.setPrototypeOf(target, prototype)

设置对象原型的函数. 返回一个 Boolean，如果更新成功，则返回true。

const obj = {}

Reflect.setPrototypeOf(obj, {aa: 1})