第13章 Reflect

1. 将 Object 对象的一些明显属于语言内容的方法（比如Object。defineProperty）放到Reflect对象上。
2. 修改某些 Object 方法的返回结果， 让其变得更合理
3. 让 Object 操作变成函数行为
4. Reflect 对象的方法与 Proxy 对象的方法一一对应， 只要是 Proxy 对象的方法， 就能在 Reflect 对象上找到对应的方法。

Reflect.apply(target, thisArg, args);            
Reflect.construct(target, args);                   //等同于 new target(...args), 提供了一种不适用 new 来调用构造函数的方法
Reflect.get(target, name, receiver);               //查找并返回 target 对象的 name 属性
Reflect.set(target, name, value, receiver);        //设置 target 对象的 name 属性等于 value
Reflect.defineProperty(target, name, desc);        //读取对象的 __proto__ 属性， 对应 Object.getPrototypeOf(obj);
Reflect.deleteProperty(target, name);              //等同于 delete obj[name], 用于删除对象的属性
Reflect.has(target, name);                         //对应 name in obj 中的 in 运算符
Reflect.ownKeys(target);
Reflect.isExtensible(target);
Reflect.preventExtensions(target);
Reflect.getOwnPropertyDescriptor(target, name);
Reflect.getPrototypeOf(target);
Reflect.setPrototypeOf(target, prototype);

13.2.1

var myObject = {
  foo: 1,
  bar: 2,
  get baz() {
    return this.foo + this.bar;
  }
}

Reflect.get(myObject, 'foo');
Reflect.get(myObject, 'bar');
Reflect.get(myObject, 'baz');

var myObject = {
  foo: 1,
  bar: 2,
  get baz() {
    return this.foo + this.bar;
  }
}

var myReceiverObject = {
  foo: 4,
  bar: 4
}

// 如果 name 属性部署了读取函数（getter）， 则读取函数的 this 绑定 receiver
Reflect.get(myObject, 'baz', myReceiverObject);
//如果第一个参数不是对象， Reflect.get 方法会报错
Reflect.get(1, 'foo')   //报错
Reflect.get(false, 'foo')

13.2.2

var myObject = {
  barfoo: 1,
  set bar(value) {
    return this.foo = value;
  }
}

myObject.foo  // 1

Reflect.set(myObject, 'foo', 2);
myObject.foo  //2

Reflect.set(myObject, 'bar', 3);
myObject.foo  //3

var myObject = {
  foo: 4,
  set bar(value) {
    return this.foo = value;
  }
}

var myReceiverObject = {
  foo: 0
}

Reflect.set(myObject, 'bar', 1, myReceiverObject);
myObject.foo    //4
myReceiverObject.foo  //1
//如果第一个参数不是对象， Reflect.set 会报错。
Reflect.set(1, 'foo', {})     //报错
Reflect.set(false, 'foo', {}) //报错

let p = {
  a: 'a
}

let handler = {
  set(target, key, value, receiver) {
    console.log('set');
    Reflect.set(target, key, value, receiver);
  },
  defineProperty(target, key, attribute) {
    console.log('defineProperty');
    Reflect.defineProperty(target, key, attribute);
  }
}

let obj = new Prox(p, handler);
obj.a = 'A';

13.2.3

var myObject = {
  foo: 1
}

// 旧写法
'foo' in myObject

//新写法
Reflect.has(myObject, 'foo');

13.2.4

const myObj = {foo: 'bar'};

//旧写法
delete myObj.foo;

//新写法
Reflect.deleteProperty(myObj, 'foo')

13.2.5

function Greeting(name) {
  this.name = name;
}

//new 的写法
const instance = new Greeting('张三');

// Reflect.construct 的写法
const instance = Reflect.construct(Greeting, ['张三'])