es6-Proxy

Proxy

Proxy对象是es6新拓展的一个构造函数。该构造函数可用于对对象的指定操作进行拦截和处理。

使用：

var objFunc = function(){
		console.log("执行原始函数");
	};

	var handler = {
		get: function(target, name){
			console.log("拦截对对象属性的读取");
			return Reflect.get(target, name);
		},

		set: function(target, name){
			console.log("拦截对对象属性的设置");
			return Reflect.set(target, name);
		},

		has: function(target, name){
			console.log("拦截对对象属性查询 name in target");
			return Reflect.has(target, name);
		},

		deleteProperty: function(target, name){
			console.log("拦截对对象属性删除 delete target[name]");
			return Reflect.deleteProperty(target, name);
		},

		ownKeys: function(target){
			console.log("拦截对对象属性获取 Object.getOwnPropertyNames(proxy)、Object.getOwnPropertySymbols(proxy)、Object.keys(proxy)");
			return Reflect.ownKeys(target);
		},

		getOwnPropertyDescriptor: function(target, name){
			console.log("拦截对象属性描述 Object.getOwnPropertyDescriptor(proxy, propKey)");
			return Reflect.getOwnPropertyDescriptor(target, name);
		},

		defineProperty: function(target, name, obj){
			console.log("拦截对象属性定义 拦截Object.defineProperty(proxy, propKey, propDesc）、Object.defineProperties(proxy, propDescs)");
			return Reflect.defineProperty(target,  "key", obj);
		},

		preventExtensions: function(target){
			console.log("拦截使对象变得不可拓展 Object.preventExtensions(proxy)");
			return Reflect.preventExtensions(target);
		},

		getPrototypeOf: function(target){
			console.log("拦截对对象非继承属性获取 Object.getPrototypeOf(proxy)");
			return Reflect.getPrototypeOf(target);
		},

		isExtensible: function(target){
			console.log("拦截判断对象是否可拓展 Object.isExtensible(proxy)");
			return Reflect.isExtensible(target);
		},

		setPrototypeOf: function(target, name){
			console.log("拦截对对象非继承属性设置 Object.setPrototypeOf(proxy, proto)");
			throw new Error(" trap returned truish for setting a new prototype on the non-extensible proxy target");
		},

		apply: function(target, object, args){
			console.log("拦截 Proxy 实例作为函数调用的操作 proxy(...args)、proxy.call(object, ...args)、proxy.apply(...)");
			return Reflect.apply(target, object, args);
		},

		construct: function(target, args){
			console.log("拦截 Proxy 实例作为构造函数调用的操作 new proxy(...args)");
			return Reflect.construct(target, args);
		},
	};

	var proxy = new Proxy(objFunc, handler);

	proxy.name; //拦截对对象属性的读取

	proxy.myName = "breakair"; //拦截对对象属性的设置

	'myName' in proxy; //拦截对对象属性查询 name in target

	delete proxy[name]; //拦截对对象属性删除 delete target[name]

	Object.getOwnPropertyNames(proxy); //拦截对对象属性获取 Object.getOwnPropertyNames(proxy)、Object.getOwnPropertySymbols(proxy)、Object.keys(proxy)

	Object.defineProperty(proxy, "key", { enumerable: false,
										  configurable: false,
										  writable: false,
										  value: "static"}); //拦截对象属性定义 拦截Object.defineProperty(proxy, propKey, propDesc）、Object.defineProperties(proxy, propDescs)

	Object.preventExtensions(proxy); //拦截使对象变得不可拓展 Object.preventExtensions(proxy)

	Object.getPrototypeOf(proxy); //拦截对对象非继承属性获取 Object.getPrototypeOf(proxy)

	Object.isExtensible(proxy); //拦截判断对象是否可拓展 Object.isExtensible(proxy)

	proxy();  //拦截 Proxy 实例作为函数调用的操作 proxy(...args)、proxy.call(object, ...args)、proxy.apply(...)
			//111.html:12 执行原始函数

	new proxy(); //拦截 Proxy 实例作为构造函数调用的操作 new proxy(...args)
				//111.html:12 执行原始函数

	Object.setPrototypeOf(proxy, {myName: 'hello'}); //拦截对对象非继承属性设置 Object.setPrototypeOf(proxy, proto) Uncaught Error:  trap returned truish for setting a new prototype on the non-extensible proxy target