基本概念

reflect是一个内置的对象，提供了拦截JavaScript操作的方法（主要作用）。它将部分属于语言内部的方法转移到reflect上去，比如defineProperty。优化了一部分函数的返回结果，它的风格上倾向于函数式编程，保留对象的默认行为（Proxy），没有构造函数，所有的属性方法都是静态的，类似Math。reflect和Proxy是一一对应的，所有Proxy可以拦截的属性，reflect提供一个默认。。

静态方法

• get ，取值操作, 不存在返回undefined

      Reflect.get(target, propertyKey[, receiver]);
  

  内部this绑定receiver

      var object1 = {
        a: 1,
        b: 2,
        get c() {
          return this.a + this.b;
        },
      };
      
      var object2 = {
        a: 4,
        b: 4,
      };
      
      Reflect.get(object1, 'c');
      // 3 
      Reflect.get(object1, 'c', object2);
      // 8 
  

• set，赋值操作

      Reflect.set(target, propertyKey, value[, receiver]);
  

  同get一样，也是内部this绑定receiver。

      var object1 = {
        a: 1,
        set b(value) {
          return this.a = value;
        },
      };
      
      var object2 = {
        a: 0,
      };
      
      Reflect.set(object1, 'b', 2, object2);
      // true
      object1
      //{a:1}
      object2
      //{a:2}
      
      object1.foo
      // undeifined 
      object2.foo;
      // undeifined  
  

  与Proxy同时使用 ， 传递receiver会触发defineProperty，触发defineProperty的前提是一定要先传递receiver。

      let object = {
        a: 1
      };
      
      let handler = {
        set(target, key, value, receiver) {
          console.log('set value', value);
          Reflect.set(target, key, value, receiver)
        },
        defineProperty(target, key, attribute) {
          console.log('defineProperty', attribute);
          Reflect.defineProperty(target, key, attribute);
        }
      };
      
      let obj = new Proxy(object, handler);
      
      obj.a = 2;
      // set value 2
         defineProperty {value: 2}
         2
  

• has，对象是否包含某个属性，返回布尔值

      Reflect.has(target, propertyKey);
      var object = {
        a: 1,
      };
      
      Reflect.has(object, 'a');
      // true 
  

• deleteProperty，删除某个属性，返回布尔值

      Reflect.deleteProperty(target, propertyKey);
      var object = {
        a: 1,
      };
      
      Reflect.deleteProperty(object, 'a');
      // true
  

• construct，new操作

      Reflect.construct(target, argumentsList[, newTarget]);
      function Teacher(name) {
        this.name = name;
      }
      
      const eric = Reflect.construct(Teacher, ['Eric']);
      // Teacher {name: "Eric"} 
  

• getPrototypeOf，读取proto属性

      Reflect.getPrototypeOf(target);
      function Teacher(name) {
        this.name = name;
      }
      const eric = Reflect.construct(Teacher, ['Eric']);
      
      Reflect.getPrototypeOf(eric) === Teacher.prototype;
      // true
  

• setPrototypeOf ， 设置目标对象原型 ， 返回布尔值

      Reflect.setPrototypeOf(target, prototype);
      const object = {};
      Reflect.setPrototypeOf(object, Array.prototype);
      object.length;
      // 0 
  

• apply ， 绑定this对象执行给定函数

      Reflect.apply(target, thisArgument, argumentsList);
      const list = [1, 2, 3, 4, 5, 6];
      const min = Reflect.apply(Math.min, Math, list);
  

• defineProperty ， 对象定义属性

      Reflect.defineProperty(target, propertyKey, attributes);
      let object = {};
      
      Reflect.defineProperty(object, 'name', {
        value: 'Eric'
      });
      // {name: "Eric"}
  

• getOwnPropertyDescriptor ， 获取指定属性的描述对象

      Reflect.getOwnPropertyDescriptor(target, propertyKey);
  

• isExtensible ， 返回指定对象是否可扩展

      Reflect.isExtensible(target);
  

• preventExtensions ， 阻止对象扩展

      Reflect.preventExtensions(target);
      var empty = {};
      Reflect.isExtensible(empty);
      /* true */
      
      Reflect.preventExtensions(empty);
      Reflect.isExtensible(empty);
      // false 
  

• ownKeys ， 返回对象的所有属性(包含Symbol)

      Reflect.ownKeys(target);
      var object = {
        a: 1,
        b: 2,
        [Symbol.for('c')]: 3,
        [Symbol.for('d')]: 4,
      };
      
      Reflect.ownKeys(object);
      // ["a", "b", Symbol(c), Symbol(d)]