ES6语法（九）Reflect

Reflect

Reflect是一个内置的对象，它提供拦截JavaScript操作的方法，这些方法与处理器对象的方法相同。Reflect不是一个函数对象，因此它是不可构造的。

与大多数全局变量不同，Reflect没有构造函数。不能将其与一个new运算符一起使用，或者将Reflect对象作为一个函数来调用。Reflect的所有属性和方法都是静态的（就像Math对象）

• Reflecr.apply()
  语法：

Reflect.apply(target, thisArgument,argumentsList)

解释:

参数	含义
target	目标函数
thisArgument	target函数调用时绑定的this对象
argumentsList	target函数调用时传入的实参列表，该参数应该是一个类数组的对象

示例：

Reflect.apply(Math.floor, null, [4.72]) //4

• ES5对比

Function.prototype.apply.call(Math.floor, undefined, [1.75])

该方法与ES5中Function prototype.apply()方法类似：调用一个方法并且显示地指定this变量和参数列表(arguments),参数列表可以是数组，或类似数组的对象。

• Reflect.construct()
  Reflect.construct()方法的行为有点想new操作符构造函数，相当于运行new target(…args)
  语法：

Reflect.construct(target, argumentsList[, newTarget])

解释:

参数	含义
target	被运行的目标函数
argumentsList	调用构造函数的数组或者伪数组
newTarget	该参数为构造函数，参考new.target操作符，如果没有newTarget参数，默认和target一样

Reflect.condtruct允许使用可变的参数调用构造函数

var obj = new Foo(...args)
var obj = Reflect.construct(Foo, args）

示例：

var d = Reflect.construct(Date, [1776, 6, 4])
d.instanceof Data //true
d.getFullYear //1776

如果使用newTarget参数，则表示继承了newTarget这个超类:

function someConstructor(){}
var result = Reflect.construt(Array, [], someConstructor)

Reflect.getPrototypeOf(result) // 输出：someConstructor.prototype
Array.isArray // true

• Reflect.defineProperty()
  静态方法Reflect.defineProperty()基本等同于Object.defineProperty()方法，唯一不同是返回Boolean值。
  语法：

Reflect.defineProperty(target, propertyKey,attrbutes)

解释：

参数	含义
target	目标对象
propertyKey	要定义或修改的属性的名称
attrbutes	要定义或修改的属性的描述

示例：

const student = {}
Reflect.defineProperty(student, "name", {value:'Mike'})  //true
student.name // "Mike"

• Reflect.deleteProperty()
  Reflect.deleteProperty允许删除一个对象上的属性，返回一个Boolean值表示该属性是否被成功删除。它几乎与非严格的delete operate相同。
  语法：

Reflect.deleteProperty(target, ppropertyKey)

解释：

参数	含义
target	删除属性的目标对象
propertyKey	将被删除的属性的名称

示例：

var obj = { x: 1, y: 2}
Reflect.deleteProperty(obj,"x") //true
obj; //{y:2}
var arr = [1,2,3,4,5]
Reflect.deleteProperty(arr,3) //true
arr; //[1,2,3, ,5]
//如果属性不存在，返回true
Reflect.deleteProperty({},"foo") //true
//如果属性不可配置，返回false
Reflect.deleteProperty(Object.freeze({foo: 1}),"foo") //true

• Reflect.get()
  Reflect.get()方法的工作方式，就像从object(target[propertyKey])中获取属性，但它是作为一个函数执行的。
  语法：

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

解释：

参数	含义
target	需要取值的目标对象
propertyKey	需要获取的值的键值
receiver	如果遇到getter，此值将提供给目标调用

示例：

//Object
var obj = { x: 1, y:  2}
Reflect.get(obj, "x") // 1

//Array
Reflect.get(['aaa', 'bbb'], 1) //'bbb'

//Proxy with a get handler
var x = { p: 1}
var obj = new Proxy(x,{
get(t, k, r){ return k + 'bar' }
})
Reflect.get(obj, 'foo') // 'foobar'

• Reflect.getOwnPropertyDescriptor()
  静态方法Reflect.getOwnPropertyDescriptor()与Object.getOwnPropertyDescriptor()方法相似。如果在对象中存在，则返回给定的属性的属性描述符，否则返回undefined。
  语法：

Reflect.getOwnPropertyDescriptor(target, propertyKey)

解释:

参数	含义
target	需要寻找属性的目标对象
propertyKey	获取自己的属性描述符的属性的名称

示例：

Reflect.getOwnPropertyDescriptor({ x: 'hello' }, 'x')
//{value: 'hello', writable: true, enumerable: true, configurable: true}

Reflect.getOwnPropertyDescriptor({ x: 'hello' }, 'y')
//undefined

Reflect.getOwnPropertyDescriptor([], 'length')
// {value: 0, writeable: true, enumerable: true, configurable: false}

对比:
如果该方法的第一个参数不是一个对象（一个原始值），那么将造成TypeError错误。而对于Object.getOwnPropertyDescriptor,非对象的第一个参数将被强制转换为一个对象处理。

Reflect.getOwnPropertyDescriptor('foo', 0)
//TypeError: 'foo' is not non-null object

Object.getOwnPropertyDescriptor('foo', 0)
// {value: 'f', writeable: false, enumerable: true, configurable: false}

• Reflect.getPrototypeOf()
  静态方法Reflect.getPrototypeOf()与Object.getPrototypeOf()方法是一样的。都是返回指定对象的原型（即，内部的[[Property]]属性值）。
  语法：

Reflect.getPrototypeOf(target)

解释：

参数	含义
target	获取原型的目标对象

• Reflect.has()
  Reflect.has用于检查一个对象是否拥有某个属性，相当于in操作符
  语法:

Reflect.has(target, propertyKey)

解释:

参数	含义
target	获取原型的目标对象
propertyKey	属性名，需要检查目标对象是否存在此属性

• Reflect.isEctensible()
  Reflect.isEctensible判断一个对象是否可扩展（即是否能够添加新的属性），它与Object.isEctensible()方法一样。
  语法:

Reflect.isEctensible(target)

解释：

参数	含义
target	获取原型的目标对象

• Reflect.ownKeys()
  Reflect.ownKeys方法返回一个目标对象自身的属性键组成的数组。它返回值等同于Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))
  语法:

Reflect.ownKeys(target)

解释：

参数	含义
target	获取原型的目标对象

示例：

Reflect.ownKeys({z: 3, y: 2, x: 1}); //['z', 'y', 'x']
Reflect.ownKeys([]) //['length']

var sym = Symbol.for('comet')
var sym2 = Symbol.for('meteor')
var obj = {[sym2]: 0, 'str': 0, '733': 0, '0': 0,
			[sym2]: 0, '-1': 0, '8': 0, 'second str': 0}
Reflect.ownKeys(obj)
// [ '0', '8', '773', 'str', '-1', 'second str', Symbol(comet), Symbol(meteor) ]
// Indexsin numeric order,
// strings in insertion roder,
// symbols in insertion order

• Reflect.preventExtensions()
  Reflect.preventExtensions方法阻止新属性添加到对象。例如：防止将来对对象的扩展被添加到对象中。该方法与Object.preventExtensions()方法一致。
  语法:

Reflect.preventExtensions(targte)

解释：

参数	含义
target	获取原型的目标对象

示例：

//Object are extensible by default
var empty = {}
Reflect.isExtensible(empty) // === true

//...but that can be changed
Reflect.preventExtensions(empty)
Reflect.isExtensible(epty) // === false

Reflect.preventExtensions(1)
//TypeError: 1 is not an object

Object.preventExtensions(1)
// 1

• Reflect.set()
  Reflect.set方法允许在对象上设置属性。它的作用是给属性赋值并且就像property accessor语法一样，但是它是以函数的方式。
  语法：

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

解释：

参数	含义
target	获取原型的目标对象
peopertyKey	设置的属性的名称
value	设置的值
receiver	如果遇到setter，this将提供给目标调用

示例：

// Object
var obj = {}
Reflect.set(obj, 'prop', 'value') // true
obj.prop // 'value'

//Array
var arr = ['duck', 'duck', 'duck']
Reflect.set(arr, 2, 'goose') // true
arr[2] //'goose'

// It can truncate an array
Reflect.set(arr, 'length', 1) // true
arr // ['duck']

//with just one argument, propertyKey and value are 'undefined'
var obj = {}
Reflect.set(obj) // true
Reflect.getOwnPropertyDescriptor(obj, 'undefined')
//{ value: undefined writable: true, enumerable: true, configursble: true }

• Reflect.setPrototypeOf()
  Reflect.setPrototypeOf方法改变指定对象的原型(即，内部的[[Prototype]]属性值)
  语法:

Reflect.setPrototypeOf(target, prototype)

解释：

参数	含义
target	获取原型的目标对象
prototye	对象的新原型(一个对象或null)

示例：

Reflect.setPrototypeOf({}, Object.prototype) // true

// It can change an object`s [[ Prototype ]] to null
Reflect.setPrototypeOf(Object.freezs({}), null) //false

//Reflect false if it cause a prototype chain cycle
var target = {}
var proto = Object.create(target)
Reflect.setPrototypeOf(target, proto) // false

以上所有API第一个参数是Object， 如果给定的不是Object则抛出一个TypeError异常。