第九章 代理与反射

ECMAScript 6 新增的代理和反射为开发者提供了拦截并向基本操作嵌入额外行为的能力。具体地 说，可以给目标对象定义一个关联的代理对象，而这个代理对象可以作为抽象的目标对象来使用。在对 目标对象的各种操作影响目标对象之前，可以在代理对象中对这些操作加以控制。

1、创建代理对象
	const target = { id: 'target' }; 
	const handler = {}; 
	//两个参数必传，不然会抛出类型错误
	const proxy = new Proxy(target, handler);

	操作 proxy,target 都会作用于目标对象
    Proxy.prototype 是 undefined,所以不能用 instanceof
    严格相等可以用于区分代理和目标
	proxy === target ;//false

2、定义捕获器
	使用代理的主要目的是可以定义捕获器（trap）。捕获器就是在处理程序对象中定义的“基本操作的 拦截器”。每个处理程序对象可以包含零个或多个捕获器，每个捕获器都对应一种基本操作，可以直接 或间接在代理对象上调用。每次在代理对象上调用这些基本操作时，代理可以在这些操作传播到目标对 象之前先调用捕获器函数，从而拦截并修改相应的行为。

const target = { foo: 'bar' }; 
const handler = { 
    // 捕获器在处理程序对象中以方法名为键 
    get() { 
        return 'handler override'; 
    } 
}; 
const proxy = new Proxy(target, handler);





//深度代理
 let data = {
    maxload:'1253.11',
    data:{
        a:1,
        b:2
    },
    arr:[1,2,3,4]
}
var handler = {
    set: function (obj, prop, newval) {
        console.log(obj, prop, newval);
        if(prop === newval)return;
        return Reflect.set(obj, prop, newval)
    }
}
var pData = toDeepProxy(data, handler) 
//如果是不是嵌套的object，直接加上proxy返回，如果是嵌套的object，那么进入addSubProxy进行递归。 
function toDeepProxy(object, handler) {
    if (!isPureObject(object)) addSubProxy(object, handler); 
    return new Proxy(object, handler);

//这是一个递归函数，目的是遍历object的所有属性，如果不是pure object,那么就继续遍历object的属性的属性，如果是pure object那么就加上proxy
    function addSubProxy(object, handler) {
        for (let prop in object) {
            if ( typeof object[prop] == 'object') {
                if (!isPureObject(object[prop])) addSubProxy(object[prop], handler);
                object[prop] = new Proxy(object[prop], handler);
            }
        }
        object = new Proxy(object, handler)
    }

//是不是一个pure object,意思就是object里面没有再嵌套object了
    function isPureObject(object) {
        if (typeof object!== 'object') {
            return false;
        } else {
            for (let prop in object) {
                if (typeof object[prop] == 'object') {
                    return false;
                }
            }
        }
        return true;
    }
}

3、反射API Rflect
	处理程序对象中所有可以捕获的方法都有对应的反射（Reflect）API 方法。这些方法与捕获器拦截 的方法具有相同的名称和函数签名，而且也具有与被拦截方法相同的行为。因此，使用反射 API 也可以 像下面这样定义出空代理对象：

const target = { foo: 'bar' }; 
const handler = { 
    get() { return Reflect.get(...arguments); } 
}; 
const proxy = new Proxy(target, handler);

//简写
const handler = { 
    get: Reflect.get
}; 



Reflect 中的静态方法

1、Reflect.construct(target, argumentsList[, newTarget])
对构造函数进行 new 操作，相当于执行 new target(...args)。

2、Reflect.deleteProperty(target, propertyKey)
作为函数的delete操作符，相当于执行 delete target[name]。

3、Reflect.get(target, propertyKey[, receiver])
获取对象身上某个属性的值，类似于 target[name]。

4、Reflect.set(target, propertyKey, value[, receiver])
将值分配给属性的函数。返回一个Boolean，如果更新成功，则返回 true。

5、Reflect.has(target, propertyKey)
判断一个对象是否存在某个属性，和 in 运算符 的功能完全相同。

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


7、Reflect.defineProperty(target, propertyKey, attributes)
和 Object.defineProperty() 类似。如果设置成功就会返回 true

8、Reflect.preventExtensions(target)
类似于 Object.preventExtensions()。返回一个Boolean。

9、Reflect.setPrototypeOf(target, prototype)
设置对象原型的函数. 返回一个 Boolean， 如果更新成功，则返回true。


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


12、Reflect.isExtensible(target)
类似于 Object.isExtensible().

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

4、可撤销代理
	Proxy 也暴露了 revocable()方法，这个方法支持撤销代理对象与目标对象的关联。撤销代理的 操作是不可逆的。而且，撤销函数（revoke()）是幂等的，调用多少次的结果都一样。撤销代理之后 再调用代理会抛出 TypeError。

const { proxy, revoke } = Proxy.revocable(target, handler);
console.log(proxy.foo); // intercepted 
console.log(target.foo); // bar 
revoke(); 
console.log(proxy.foo); // TypeError

5、可多层代理 代理代理对象 


6、代理的问题与不足
	-1、代理中的 this
	-2、代理与内部槽位
    	代理与内置引用类型（比如 Array）的实例通常可以很好地协同，但有些 ECMAScript 内置类型可 能会依赖代理无法控制的机制，结果导致在代理上调用某些方法会出错。如：Date对象
        Date 类型方法的执行依赖 this 值上的 内部槽位[[NumberDate]]。代理对象上不存在这个内部槽位，而且这个内部槽位的值也不能通过普通的get,set操作访问到。于是代理拦截后会报错

• 本文作者： 王不留行
• 本文链接： https://wyf195075595.github.io/2022/06/17/programming/红宝书笔记/第九章 代理与反射/
• 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！