Object.defineProperty、Proxy、Reflect 三大对象介绍

Object.defineProperty

对象是由多个键值对组成的无序集合，对象中每个属性对应任意类型的值。在修改对象属性时，可以使用字面量进行修改，还可以使用 Object.defineProperty 为对象定义新的属性，或修改原有的属性。

语法：

Object.defineProperty(obj, prop, descriptor)

参数说明：

obj：必需。目标对象

prop：必需。需定义或修改的属性名称

descriptor：必需。目标属性所拥有的特性

返回值：

传入函数的对象，即第一个参数 obj

数据描述

当修改或定义对象的某个属性的时候，给这个属性添加一些特性：

Object.defineProperty({}, 'propName', {
    value: '', // 属性对应的值，可以是任意类型的值，默认为 undefined
    writable: true | false, // 属性的值是否可以被重写，true 可以重新，false 不能重新，默认false
    configurable: true | false, // 是否可以删除或修改属性的特性，true可以，false不可以
    enumerable: true | false, // 属性是否可以被枚举，true可以，false不可以
})

存取器描述

当使用存取器描述属性特性的时候，允许设置以下特性属性：

Object.defineProperty({}, 'propName', {
    get: function(){} | undefined, // 获取对象某个属性时调用
    set: function(){} | undefined, // 设置对象某个属性的值时调用
    configurable: true | false,
    enumerable: true | false
})

注意：当使用了 getter 或 setter 方法，不允许使用 writable 和 value 两个属性。

Proxy

Proxy 可以理解成，在目标对象之前设置了一层“拦截”，外界对该对象的访问，都必须先通过这层拦截，因此提供了一种机制，可以对外界的访问进行过滤和改写。Proxy 这个词的原意就是代理，用在这里表示由它来“代理”某些操作。

语法：

var proxy = new Proxy(target, handler)

参数解释：

target：所要拦截的目标对象

handler：是一个对象，用来定制拦截的行为

Proxy 对象用于创建一个对象的代理，从而实现基本操作的拦截和自定义，比如：属性查找、属性赋值、属性枚举、函数调用等。

Proxy 的拦截方法（实例方法）有13种：

get()
set()
getPrototypeOf()
setPrototypeOf()
has()
defineProperty()
deleteProperty()
apply()
construct()
ownKeys()
getOwnPropertyDescriptor()
preventExtensions()
isExtensible()

• get()：拦截对象属性的读取，比如proxy.foo和proxy[‘foo’]
• set()： 拦截对象属性的设置，比如proxy.foo = v或proxy[‘foo’] = v，返回一个布尔值
• getPrototypeOf()： 拦截Object.getPrototypeOf(proxy)，返回一个对象
• setPrototypeOf()： 拦截Object.setPrototypeOf(proxy, proto)，返回一个布尔值。如果目标对象是函数，那么还有两种额外操作可以拦截
• has()： 拦截propKey in proxy的操作，返回一个布尔值
• defineProperty()： 拦截Object.defineProperty(proxy, propKey, propDesc）、Object.defineProperties(proxy, propDescs)，返回一个布尔值
• deleteProperty() ： 拦截delete proxy[propKey]的操作，返回一个布尔值
• apply()： 拦截Proxy实例作为函数调用的操作，比如proxy(...args)、proxy.call(object, ...args)、proxy.apply(...)
• construct()： 拦截 Proxy 实例作为构造函数调用的操作，比如new proxy(…args)
• ownKeys()： 拦截Object.getOwnPropertyNames(proxy)、Object.getOwnPropertySymbols(proxy)、Object.keys(proxy)、for…in循环，返回一个数组。该方法返回目标对象所有自身的属性的属性名，而Object.keys()的返回结果仅包括目标对象自身的可遍历属性
• getOwnPropertyDescriptor()： 拦截Object.getOwnPropertyDescriptor(proxy, propKey)，返回属性的描述对象
• preventExtensions()： 拦截Object.preventExtensions(proxy)，返回一个布尔值
• isExtensible()： 拦截Object.isExtensible(proxy)，返回一个布尔值

Proxy.revocable()

Proxy.revocable() 方法返回一个可取消的 Proxy 实例

let target = {};
let handler = {};

let {proxy, revoke} = Proxy.revocable(target, handler);

proxy.foo = 123;
proxy.foo // 123

revoke();
proxy.foo // TypeError: Revoked

Proxy.revocable() 方法返回一个对象，该对象的 proxy 属性是 Proxy 实例， revoke 属性是一个函数，可以取消 Proxy 实例。上面代码中，当执行 revoke() 函数后，在访问 Proxy 实例，就会抛出异常。

Proxy.revocable() 的使用场景是，目标对象不允许直接访问，必须通过代理访问，一旦访问结束，就收回代理权，不允许再次访问。

Reflect

设计目的：

1. 将 Object 对象的一些明显属于语言内部的方法放到 Reflect 对象上，例如 Object.defineProperty() ;
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 上获取默认行为；

let obj = {}
let proxy = new Proxy(obj, {
    get(target, propName) {
        // 修改 Proxy 的默认行为，为每一步操作输出了日志
        console.log('这里修改了默认行为')
        
        // 返回结果保证了原有行为能够正常执行
        return Reflect.get(target, propName)
    },
    deleteProperty(target,propName) {
        return Reflect.deleteProperty(target,propName)
    },
    has(target, propName) {
        return Reflect.has(target, propName)
    }
})

Reflect 对象一共有13个静态方法，这些方法也是 Proxy 对象的实例方法：

Reflect.apply(target, thisArg, args)
Reflect.construct(target, args)
Reflect.get(target, name, receiver)
Reflect.set(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.getOwnPropertyDescriptor(target, name)
Reflect.getPrototypeOf(target)
Reflect.setPrototypeOf(target, prototype)

上面的这些方法，大部分与 Object 对象的同名方法的作用都是相同的，而且它与 Proxy 对象的方法是一一对应的。