let obj = new Proxy({},{
      get: function(target,propKey,receiver) {
        console.log(`获取的时候会被拦截`)
        console.log(target,propKey,receiver)
        return Reflect.get(target,propKey,receiver)
      },
      set: function(target,propKey,value,receiver) {
        console.log(`设置时被拦截`);
        console.log(target,propKey,value,receiver)
        return Reflect.set(target,propKey,value,receiver)
      }
})
console.log(obj) // Proxy {}

obj.count = 1
// 设置时被拦截
// {} "count" 1 Proxy {}

++obj.count
// 获取的时候会被拦截
// {count: 1} "count" Proxy {count: 1}
// 设置时被拦截
// {count: 1} "count" 2 Proxy {count: 1}

let porxy1 = new Proxy({},{
  get: function(target,propKey) {
    if(propKey === 'time') {
      return 99
    }
    return 100
  }
})
console.log(porxy1.age) // 100
console.log(porxy1.time) //  99

// hander没有设置任何拦截，等于直接通向原对象，没有任何拦截效果，访问proxy就等同于访问target
let target = {}
let hander = {}
let proxy2 = new Proxy(target,hander)
proxy2.name = 'xiao'
console.log(proxy2.name)  // xiao

// proxy对象是obj对象的原型，obj对象本身并没有time属性，
// 所以根据原型链，会在proxy对象上读取该属性，导致被拦截
let proxy3 = new Proxy({},{
  get: function(target,propKey) {
    return 419
  }
})
let obj1 = Object.create(proxy3)
console.log(obj1.name) // 419

发问，vue3的响应式为什么Object.defineProperty() 要改成Proxy，看下面：

Object.defineProperty(obj, prop, descriptor)
// 显式
Object.defineProperty(obj, "key", {
  enumerable: false,
  configurable: false,
  writable: false,
  value: "static"
})

// configurable  当且仅当该属性的 configurable 键值为 true 时，
//该属性的描述符才能够被改变，同时该属性也能从对应的对象上被删除。 默认为 false。

// enumerable  当且仅当该属性的 enumerable 键值为 true 时，
// 该属性才会出现在对象的枚举属性中。 默认为 false。

// value该属性对应的值。可以是任何有效的 JavaScript 值（数值，对象，函数等）。
// 默认为 undefined。

//writable 当且仅当该属性的 writable 键值为 true 时，属性的值，
// 也就是上面的 value，才能被赋值运算符 (en-US)改变。 默认为 false。

//get 属性的 getter 函数，如果没有 getter，则为 undefined。
//当访问该属性时，会调用此函数。执行时不传入任何参数，但是会传入 this 对象（由于继承关系，
// 这里的this并不一定是定义该属性的对象）。该函数的返回值会被用作属性的值。 默认为 undefined。

//set 属性的 setter 函数，如果没有 setter，则为 undefined。
// 当属性值被修改时，会调用此函数。该方法接受一个参数（也就是被赋予的新值），
// 会传入赋值时的 this 对象。 默认为 undefined。

var o = {}; // 创建一个新对象
var bValue = 38;
Object.defineProperty(o, "b", {
  // 使用了方法名称缩写（ES2015 特性）
  // 下面两个缩写等价于：
  // get : function() { return bValue; },
  // set : function(newValue) { bValue = newValue; },
  get() { return bValue; },
  set(newValue) { bValue = newValue; },
  enumerable : true,
  configurable : true
});

Object.defineProperty() 就上面那几把梭，看看proxy，好几把梭，换换换

var handler = {
  get: function(target, name) {
    if (name === 'prototype') {
      return Object.prototype;
    }
    return 'Hello, ' + name;
  },

  apply: function(target, thisBinding, args) {
    return args[0];
  },

  construct: function(target, args) {
    return {value: args[1]};
  }
};

var fproxy = new Proxy(function(x, y) {
  return x + y;
}, handler);

fproxy(1, 2) // 1
new fproxy(1, 2) // {value: 2}
fproxy.prototype === Object.prototype // true
fproxy.foo === "Hello, foo" // true

对于可以设置、但没有设置拦截的操作，则直接落在目标对象上，按照原先的方式产生结果。

下面是 Proxy 支持的拦截操作一览，一共 13 种。

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