ES6新特性之Reflect

基本概念

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)]
  

转载于:https://my.oschina.net/u/4144971/blog/3096218