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