类似于代理模式，相当于在目标对象前架设了一个拦截层，提供了一种对对象进行过滤改写的方法。

使用方法

（1）定义handler代理对象，该对象里面是一系列的过滤函数
（2）创建目标对象var proxy = new Proxy(target,handler),对target对象进行handler的过滤

handler对象里面常用的方法

get(target,key):读取
set(target,key,value)修改
has(target,key)判断对象是否有某个属性
apply(target,object,args)拦截函数的调用
construct(target,args)拦截new命令

一个读取属性的代理例子

当读取的属性不在该对象时，返回-1

handle = {
    get(target,key){
        if(key in target){
            return target[key]
        }
        else{
            return -1
        }
    }
}

obj={
    name:'jack'
}
var person = new Proxy(obj,handle)
console.log(person.name)   //jack
console.log(person.age)   //-1

一个封装私有属性的例子

默认以_开头的属性时私有属性

var people = {
    name:'jack',
    _age:18
}

handler = {
    get(target,key){
        if(key.startsWith('_')){
            console.log('私有属性不能访问')
            return false
        }
        else{
            return target[key]
        }
    },

    set(target,key,value){
        if(key.startsWith('_')){
            console.log('私有属性不能改写')
            return false
        }
        else{
            target[key] = value
            return target[key]
        }
    },

    has(target,key){
        if(key in target){
            if(key.startsWith('-')){
                console.log('私有变量不能看到')
                return false
            }
            else{
                return true
            }
        }
        else{
            return false
        }
    }
}

var proxy = new Proxy(people,handler)

console.log(proxy.name)
console.log(proxy._age)