Proxy 可以理解成,在目标对象之前架设一层“拦截”,外界对该对象的访问,都必须先通过这层拦截,因此提供了一种机制,可以对外界的访问进行过滤和改写。
var proxy = new Proxy(target, handler);
new Proxy()
表示生成一个Proxy
实例,target
参数表示所要拦截的目标对象,handler
参数也是一个对象,用来定制拦截行为。
如果handler
没有设置任何拦截,那就等同于直接通向原对象。
var target = {}; var handler = {}; var proxy = new Proxy(target, handler); proxy.a = 'b'; target.a // "b"
上面代码中,handler
是一个空对象,没有任何拦截效果,访问proxy
就等同于访问target
。
同一个拦截器函数,可以设置拦截多个操作。
//原始对象储存真实数据 let obj={ time:'2017-03-11', name:'net', _r:123 }; let monitor=new Proxy(obj,{ // 拦截对象属性的读取 get(target,key){ return target[key].replace('2017','2018') }, // 拦截对象设置属性 set(target,key,value){ if(key==='name'){ return target[key]=value; }else{ return target[key]; } }, // 拦截key in object操作 has(target,key){ if(key==='name'){ return target[key] }else{ return false; } }, // 拦截delete deleteProperty(target,key){ if(key.indexOf('_')>-1){ delete target[key]; return true; }else{ return target[key] } }, // 拦截Object.keys,Object.getOwnPropertySymbols,Object.getOwnPropertyNames ownKeys(target){ return Object.keys(target).filter(item=>item!='time') } }); console.log(monitor.time); //2018-03-11 monitor.time='2018'; monitor.name='mukewang'; console.log(monitor.time,monitor); //2018-03-11 Proxy {time: "2017-03-11", name: "net", _r: 123} console.log('name' in monitor,'time' in monitor); //true false console.log(Object.keys(monitor)); // ["name", "_r"]
Proxy 支持的拦截操作一览,一共 13 种。
- get(target, propKey, receiver):拦截对象属性的读取,比如
proxy.foo
和proxy['foo']
。 - set(target, propKey, value, receiver):拦截对象属性的设置,比如
proxy.foo = v
或proxy['foo'] = v
,返回一个布尔值。 - has(target, propKey):拦截
propKey in proxy
的操作,返回一个布尔值。 - deleteProperty(target, propKey):拦截
delete proxy[propKey]
的操作,返回一个布尔值。 - ownKeys(target):拦截
Object.getOwnPropertyNames(proxy)
、Object.getOwnPropertySymbols(proxy)
、Object.keys(proxy)
、for...in
循环,返回一个数组。该方法返回目标对象所有自身的属性的属性名,而Object.keys()
的返回结果仅包括目标对象自身的可遍历属性。 - getOwnPropertyDescriptor(target, propKey):拦截
Object.getOwnPropertyDescriptor(proxy, propKey)
,返回属性的描述对象。 - defineProperty(target, propKey, propDesc):拦截
Object.defineProperty(proxy, propKey, propDesc)
、Object.defineProperties(proxy, propDescs)
,返回一个布尔值。 - preventExtensions(target):拦截
Object.preventExtensions(proxy)
,返回一个布尔值。 - getPrototypeOf(target):拦截
Object.getPrototypeOf(proxy)
,返回一个对象。 - isExtensible(target):拦截
Object.isExtensible(proxy)
,返回一个布尔值。 - setPrototypeOf(target, proto):拦截
Object.setPrototypeOf(proxy, proto)
,返回一个布尔值。如果目标对象是函数,那么还有两种额外操作可以拦截。 - apply(target, object, args):拦截 Proxy 实例作为函数调用的操作,比如
proxy(...args)
、proxy.call(object, ...args)
、proxy.apply(...)
。 - construct(target, args):拦截 Proxy 实例作为构造函数调用的操作,比如
new proxy(...args)
。
Proxy 实例的方法
下面是上面这些拦截方法的详细介绍。
get()
//原始对象储存真实数据 let obj={ time:'2017-03-11', name:'net', _r:123 }; let monitor=new Proxy(obj,{ // 拦截对象属性的读取 get(target,key){ return target[key].replace('2017','2018') } }); console.log(monitor.time,monitor); //2018-03-11 Proxy {time: "2017-03-11", name: "net", _r: 123} //只是读取显示的值变了,实际的值并没有改变
set()
//原始对象储存真实数据 let obj={ time:'2017-03-11', name:'net', _r:123 }; let monitor=new Proxy(obj,{ // 拦截对象属性的读取 get(target,key){ return target[key].replace('2017','2018') }, // 拦截对象设置属性 set(target,key,value){ if(key==='name'){ return target[key]=value; }else{ return target[key]; } } }); monitor.time='2018'; console.log(monitor.time); //2017-03-11 set中设置不做改变 monitor.name='sun menghua'; console.log(monitor.time,monitor); //2018-03-11 Proxy {time: "2017-03-11", name: "sun menghua", _r: 123} //因为get monitor.time发生了改变
ownkeys()
for...in
循环也受到ownKeys
方法的拦截。
const obj = { hello: 'world' }; const proxy = new Proxy(obj, { ownKeys: function () { return ['a', 'b']; } }); for (let key in proxy) { console.log(key); // 没有任何输出 }
上面代码中,ownkeys
指定只返回a
和b
属性,由于obj
没有这两个属性,因此for...in
循环不会有任何输出。