js Reflect的介绍

Reflect：是一个内置的对象，它提供了一组与 js 对象相关的方法，这些方法与 Proxy 对象的钩子函数相对应，

Reflect对象的原型是Object，
	意味着，Reflect 是基于 Object 对象的原型继承而来的，
	意味着，Reflect 对象继承了 Object 对象的方法和属性，Reflect 对象本身并没有自己的原型，而是直接继承自 Object 对象。

验证Reflect的原型是Object

	log( Reflect.__proto__ === Object.prototype ) // true

---

Reflect-设计目的-1

	将Object对象的一些明显属于语言内部的方法（如：object.defineProperty）放到Reflect对象上，
	现阶段，某些方法同时在Object、Reflect上部署，未来的新方法将只部署在Reflecrt上，
	也就是说，从Reflect对象上能拿到语言内部的方法。

Reflect-设计目的-2

	修改某些Object方法的返回结果，让其变得更合理，比如：
	Object.definProperty(给哪个对象添加属性，'添加的属性名'，配置项{})，如果出现异常，会抛出一个错误，需要try...catch去捕获
    而，Reflect.defineProperty(给哪个对象添加属性，'添加的属性名'，配置项{})，如果出现异常，则会返回false

  try {
    Object.defineProperty(target, property, attributes)
  } catch (error) {
    // 失败
  }

  
  if (Reflect.defineProperty(target, property, attributes)) {
    // success
  } else {
    // error
  }

Reflect-设计目的-3

	让Object操作都变成函数行为，
    某些Object操作是命令式，比如：（name in Obj）和（delete Obj[name]）
    而，Reflect.has(obj, name) 和 Reflect.delete(obj, name)让它们变成了函数行为

  // 老写法：
  log( 'assign' in Object ) // true

  // 新写法：
  log( Reflect.has(Object, 'assign') ) // true
  log( Reflect.has({a:1, b:2}, 'a')) ) // true
  log( Reflect.has({a:1, b:2}, 'c')) ) // false

Reflect-设计目的-4

	Reflect对象的方法 与 Proxy对象的方法，一一对应
    只要是Proxy对象的方法，就能在Reflect对象上找到对应的方法，
    这就让Proxy对象可以随便调用对应的Reflect方法，完成默认行为，作为修改行为的基础，
    也就是说，不管Proxy怎么修改默认行为，你总是可以在Reflect上获取默认行为。

  // 例子-1
  let result = new Proxy(target, {
    set(target, property, value, receiver) {
      let success = Reflect.set(target, property, value, receiver)
      if (success) {
        console.log(`${target}的${property}属性被修改为${value}`)
      }
      return success
    }
  })
  // 上述代码中，Proxy方法拦截target对象的属性赋值行为，它采用Reflect.set()方法将值赋值给对象的属性。


  // 例子-2
  let resProxy = new Proxy(obj, {
    get(target, property) {
      return Reflect.get(target, property)
    },

    deleteProperty(target, property) {
      return Reflect.defineProperty(target, property)
    },

    has(target, property) {
      return Reflect.has(target, property)
    }
  })
  // 每个Proxy对象的拦截操作(get、delete、has)，内部都调用对应的Reflect方法，保证原生行为能够正常执行。