方法

2023年08月17日

柏拉文

越努力，越幸运

一、Reflect.apply()

静态方法Reflect.apply()通过指定的参数列表发起对目标(target)函数的调用。该方法与ES5中Function.prototype.apply()方法类似：调用一个方法并且显式地指定this变量和参数列表(arguments) ，参数列表可以是数组，或类似数组的对象。

语法

Reflect.apply(target, thisArgument, argumentsList)

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

返回值

返回值是调用完带着指定参数和this值的给定的函数后返回的结果。

应用场景

调用Math方法

调用 Math.floor()
const num = Reflect.apply(Math.floor,undefined,[1.75]);
console.log(num); // 1

调用 Math.max()
const array = [10,20,30,40,50,60,70];
const result = Reflect.apply(Math.max,undefined,array);
console.log(result); // 70

二、Reflect.construct()

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

语法

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

target: 被运行的目标构造函数
argumentsList: 类数组，目标构造函数调用时的参数。
newTarget: 作为新创建对象的原型对象的constructor属性，参考 new.target 操作符，默认值为target。

返回值

以target（如果newTarget存在，则为newTarget）函数为构造函数，argumentList为其初始化参数的对象实例。

应用场景

同new、Object.create()一样创建对象

通过 new 创建对象,如果不使用 new 调用构造函数，构造函数内部的 new.target 值会自动指向 undefined
function Person(name,age){
  this.name = name;
  this.age = age;
}

const person = new Person('柏拉图',23);
console.log(person); // Person {name: '柏拉图', age: 23}

通过 Object.create() 创建对象
const obj = {
  name:'柏拉图',
  age:23
}

const objCopy = Object.create(obj,{
  name:{
    value:'objCopy 柏拉图',
    writable:true,
    enumerable:true,
    configurable:true
  },
  age:{
    value:'objCopy 23', 
    writable:true,
    enumerable:true,
    configurable:true
  }
});

console.log(objCopy); // {name: 'objCopy 柏拉图', age: 'objCopy 23'}

通过 Reflect.construct() 创建对象, new.target 值自动指向到 target
function Person(name,age){
  this.name = name;
  this.age = age;
}
function Animal(color){
  this.color = color;
}

const person = Reflect.construct(Person,['柏拉图',23]);
console.log(person);

三、Reflect.defineProperty()

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

语法

Reflect.defineProperty(target, propertyKey, attributes)

target: 目标对象
propertyKey: 要定义或修改的属性的名称
attributes: 要定义或修改的属性的描述

返回值

Boolean 值指示了属性是否被成功定义。

应用场景

通过Object.defineProperty()和Reflect.defineProperty()精确添加或修改对象上的属性

通过 Object.defineProperty() 管理对象属性
const obj = {};
const resultName = Object.defineProperty(obj,'name',{
  value:'柏拉图',
  writable:true,
  enumerable:true,
  configurable:true
});
console.log(resultName); // {name: '柏拉图'}

const resultAge = Object.defineProperty(obj,'age',{
  value:'年龄',
  writable:true,
  enumerable:true,
  configurable:true
});
console.log(resultAge); // {name: '柏拉图', age: '年龄'}

console.log(obj); // {name: '柏拉图', age: '年龄'}

通过 Reflect.defineProperty() 管理对象属性
const obj = {};
const resultName = Reflect.defineProperty(obj,'name',{
  value:'柏拉图',
  writable:true,
  enumerable:true,
  configurable:true
});
console.log(resultName); // true

const resultAge = Reflect.defineProperty(obj,'age',{
  value:'年龄',
  writable:true,
  enumerable:true,
  configurable:true
});
console.log(resultAge); // true

console.log(obj); // {name: '柏拉图', age: '年龄'}

四、Reflect.deleteProperty()

静态方法Reflect.deleteProperty()允许用于删除属性。它很像delete operator，但它是一个函数。

语法

Reflect.deleteProperty(target, propertyKey)

target: 删除属性的目标对象
propertyKey: 需要删除的属性的名称

返回值

Boolean 值表明该属性是否被成功删除

应用场景

通过delete操作符或者Reflect.delete()删除对象属性

通过 delete 删除对象属性
const obj = {
  name:'柏拉图',
  age:23
}

delete obj.name;
console.log(obj); // {age: 23}

通过 Reflect.delete() 删除对象属性
const obj = {
  name:'柏拉图',
  age:23
}

Reflect.deleteProperty(obj,'name');
console.log(obj); // {age: 23}

五、Reflect.get()

**Reflect.get()**方法与从对象 (target[propertyKey]) 中读取属性类似，但它是通过一个函数执行来操作的。

语法

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

target: 需要取值的目标对象
propertyKey: 需要获取的值的键值
receiver: 如果target对象中指定了getter，receiver则为getter调用时的this值。

返回值

属性的值。

应用场景

通过ojb/数组[属性名/索引]或者Reflect.get(对象/数组,属性名/索引)访问对象/数组属性/元素

通过 ojb/数组[属性名/索引] 访问对象/数组属性/元素
const obj = {
  name:'柏拉图',
  age:23
}

const array = [10,20,30,40,50];

const resultObjName = obj['name'];
const resultArray1 = array[1];

console.log(resultObjName); // 柏拉图
console.log(resultArray1); // 20

通过 Reflect.get(对象/数组,属性名/索引) 访问对象/数组属性/元素
const obj = {
  name:'柏拉图',
  age:23
}

const array = [10,20,30,40,50];

const resultObjName = Reflect.get(obj,'name');
const resultArray1 = Reflect.get(array,1);

console.log(resultObjName); // 柏拉图
console.log(resultArray1); // 20

六、Reflect.getOwnPropertyDescriptor()

静态方法**Reflect.getOwnPropertyDescriptor()与Object.getOwnPropertyDescriptor()方法相似。如果在对象中存在，则返回给定的属性的属性描述符。否则返回 undefined。与Object.getOwnPropertyDescriptor()**的唯一不同在于如何处理非对象目标。如果该方法的第一个参数不是一个对象（原始值），那么将造成一个 TypeError 异常。对于 Object.getOwnPropertyDescriptor()，非对象的第一个参数会被强制转换为一个对象。语法

Reflect.getOwnPropertyDescriptor(target, propertyKey)

target: 需要寻找属性的目标对象。
propertyKey: 获取自己的属性描述符的属性的名称。

返回值

如果属性存在于给定的目标对象中，则返回属性描述符；否则，返回 undefined。

应用场景

通过Object.getOwnPropertyDescriptor或者Reflect.getOwnPropertyDescriptor获取对象自身属性描述符

通过 Object.getOwnPropertyDescriptor 获取对象自身属性的描述符
const obj = {
  name:'柏拉图',
  age:23
}

const array = [10,20,30,40,50];

const resultObjName = Object.getOwnPropertyDescriptor(obj,'name');
const resultArray1 = Object.getOwnPropertyDescriptor(array,1);

console.log(resultObjName); // {value: '柏拉图', writable: true, enumerable: true, configurable: true}
console.log(resultArray1); // {value: 20, writable: true, enumerable: true, configurable: true}

通过 Reflect.getOwnPropertyDescriptor 获取对象自身属性的描述符
const obj = {
  name:'柏拉图',
  age:23
}

const array = [10,20,30,40,50];

const resultObjName = Reflect.getOwnPropertyDescriptor(obj,'name');
const resultArray1 = Reflect.getOwnPropertyDescriptor(array,1);

console.log(resultObjName); // {value: '柏拉图', writable: true, enumerable: true, configurable: true}
console.log(resultArray1); // {value: 20, writable: true, enumerable: true, configurable: true}

通过Object.getOwnPropertyDescriptor或者Reflect.getOwnPropertyDescriptor处理非对象时各自的表现

通过 Object.getOwnPropertyDescriptor 处理非对象时的表现
const obj = {
  name:'柏拉图',
  age:23
}

const array = [10,20,30,40,50];

const resultObjName = Object.getOwnPropertyDescriptor('','name');
const resultArray1 = Object.getOwnPropertyDescriptor('',1); 

console.log(resultObjName); // undefined
console.log(resultArray1); // undefined

通过 Reflect.getOwnPropertyDescriptor 处理非对象时的表现
const obj = {
  name:'柏拉图',
  age:23
}

const array = [10,20,30,40,50];

const resultObjName = Reflect.getOwnPropertyDescriptor('','name'); // 报错 Reflect.getOwnPropertyDescriptor called on non-object
const resultArray1 = Reflect.getOwnPropertyDescriptor('',1); // 报错 Reflect.getOwnPropertyDescriptor called on non-object

七、Reflect.getPrototypeOf()

静态方法**Reflect.getPrototypeOf()与Object.getPrototypeOf()方法几乎是一样的。都是返回指定对象的原型（即内部的 [[Prototype]] 属性的值）。与Object.getPrototypeOf()**的唯一不同在于如何处理非对象目标。如果该方法的第一个参数不是一个对象（原始值），那么将造成一个 TypeError 异常。对于 Object.getPrototypeOf()，非对象的第一个参数会被强制转换为一个对象。

语法

Reflect.getPrototypeOf(target)

target: 获取原型的目标对象

返回值

给定对象的原型。如果给定对象没有继承的属性，则返回 null。

应用场景

通过Object.getPrototypeOf()或者Reflect.getPrototypeOf()获取对象自身属性描述符

通过 Object.getPrototypeOf() 获取对象自身属性的描述符
const obj = {
  name:'柏拉图',
  age:23
}
const objCopy = Object.create(obj);


const resultObj = Object.getPrototypeOf(objCopy);
console.log(resultObj);  // {name: '柏拉图', age: 23}

通过 Reflect.getPrototypeOf() 获取对象自身属性的描述符
const obj = {
  name:'柏拉图',
  age:23
}
const objCopy = Object.create(obj);


const resultObj = Reflect.getPrototypeOf(objCopy);
console.log(resultObj);  // {name: '柏拉图', age: 23}

通过Object.getPrototypeOf()或者Reflect.getPrototypeOf()处理非对象时各自的表现

通过 Object.getPrototypeOf() 处理非对象时的表现
const resultObj = Object.getPrototypeOf(''); 
console.log(resultObj); // String {'', constructor: ƒ, anchor: ƒ, big: ƒ, blink: ƒ, …}

通过 Reflect.getPrototypeOf() 处理非对象时的表现
const resultObj = Reflect.getPrototypeOf(''); // 报错 Reflect.getPrototypeOf called on non-object

八、Reflect.has()

静态方法Reflect.has()作用与in操作符相同。如果该方法的第一个参数不是一个对象（原始值），那么将造成一个 TypeError 异常。

语法

Reflect.has(target, propertyKey)

target: 目标对象
propertyKey: 属性名，需要检查目标对象是否存在此属性

返回值

一个 Boolean 类型的对象指示是否存在此属性

应用场景

通过in操作符或者Reflect.has()检测对象是否存在某个属性

通过 in 操作符检测对象是否存在某个属性
const obj = {
  name:'柏拉图',
  age:23
}

const result = 'name' in obj;
console.log(result); // true

通过 Reflect.has() 检测对象是否存在某个属性
const obj = {
  name:'柏拉图',
  age:23
}

const result = Reflect.has(obj,'name')
console.log(result); // true

九、Reflect.isExtensible()

静态方法**Reflect.isExtensible()**判断一个对象是否可扩展（即是否能够添加新的属性）。与它 Object.isExtensible() 方法相似，但有一些不同，如果该方法的第一个参数不是一个对象（原始值），那么将造成一个 TypeError 异常。对于 Object.isExtensible()，非对象的第一个参数会被强制转换为一个对象。

语法

Reflect.isExtensible(target)

target: 检查是否可扩展的目标对象。

返回值

返回一个 Boolean 值表明该对象是否可扩展。

应用场景

通过Object.isExtensible()或者Reflect.isExtensible()检测对象是否可扩展

通过 Object.isExtensible() 检测对象是否可以扩展
const obj = {
  name:'柏拉图',
  age:23
}

const result = Object.isExtensible(obj);
console.log(result); // true

通过 Reflect.isExtensible() 检测对象是否可以扩展
const obj = {
  name:'柏拉图',
  age:23
}

const result = Reflect.isExtensible(obj);
console.log(result); // true

十、Reflect.ownKeys()

静态方法Reflect.ownKeys()返回一个由目标对象自身的属性键组成的数组。Reflect.ownKeys方法返回一个由目标对象自身的属性键组成的数组。它的返回值等同于Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))。如果目标不是Object，抛出一个TypeError。

语法

Reflect.ownKeys(target)

target: 获取自身属性键的目标对象

返回值

由目标对象的自身属性键组成的 Array。

应用场景

通过Object.getOwnPropertyNames()、Object.getOwnPropertySymbols()或者Reflect.ownKeys()获取对象自身可枚举属性

通过 Object.getOwnPropertyNames() 和 Object.getOwnPropertySymbols() 获取对象自身可枚举属性
const s1Symbol = Symbol('s1Symbol');
const s2Symbol = Symbol('s2Symbol');
const obj = {
  name:'柏拉图',
  age:23,
  [s1Symbol]:'s1Symbol',
  [s2Symbol]:'s2Symbol'
}

const resultCommonProperty = Object.getOwnPropertyNames(obj);
const resultSymbolProperty = Object.getOwnPropertySymbols(obj);

console.log(resultCommonProperty); // ['name', 'age']
console.log(resultSymbolProperty); // [Symbol(s1Symbol), Symbol(s2Symbol)]
console.log(resultCommonProperty.concat(resultSymbolProperty)); // ['name', 'age', Symbol(s1Symbol), Symbol(s2Symbol)]

通过 Reflect.ownKeys() 获取对象自身可枚举属性
const s1Symbol = Symbol('s1Symbol');
const s2Symbol = Symbol('s2Symbol');
const obj = {
  name:'柏拉图',
  age:23,
  [s1Symbol]:'s1Symbol',
  [s2Symbol]:'s2Symbol'
}

const resultProperty = Reflect.ownKeys(obj);
console.log(resultProperty); // ['name', 'age', Symbol(s1Symbol), Symbol(s2Symbol)]

十一、Reflect.preventExtensions()

静态方法Reflect.preventExtensions()方法阻止新属性添加到对象 (例如：防止将来对对象的扩展被添加到对象中)。如果该方法的target参数不是一个对象（是原始值），那么将造成一个TypeError异常。对于Object.preventExtensions()方法，非对象的target参数将被强制转换为对象。

语法

Reflect.preventExtensions(target)

target: 阻止扩展的目标对象

返回值

返回一个 Boolean 值表明目标对象是否成功被设置为不可扩展

应用场景

**通过Object.preventExtensions()或者Reflect.preventExtensions()设置对象为属性不可扩展

通过 Object.preventExtensions() 设置对象属性为不可扩展
const obj = {}

if(Object.isExtensible(obj)){
  Object.preventExtensions(obj);
}

obj.name = '柏拉图';
console.log(obj); // {}

通过 Reflect.preventExtensions() 设置对象属性为不可扩展
const obj = {}

if(Reflect.isExtensible(obj)){
  Reflect.preventExtensions(obj);
}

obj.name = '柏拉图';
console.log(obj); // {}

十二、Reflect.set()

静态方法Reflect.set() 工作方式就像在一个对象上设置一个属性。

语法

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

target: 设置属性的目标对象。
propertyKey: 设置的属性的名称。
value: 设置的值。
receiver: 如果遇到 setter，receiver则为setter调用时的this值。

返回值

返回一个 Boolean 值表明是否成功设置属性

应用场景

通过ojb/数组[属性名/索引]或者Reflect.get(对象/数组,属性名/索引)设置对象/数组属性/元素

通过 ojb/数组[属性名/索引] 设置对象/数组属性/元素
const obj = {}
const array = [];

obj['name']='柏拉图';
array[1]=20;

console.log(obj);  // {name: '柏拉图'}
console.log(array); //  [empty, 20]

通过 Reflect.get(对象/数组,属性名/索引) 设置对象/数组属性/元素
const obj = {}
const array = [];

Reflect.set(obj,'name','柏拉图');
Reflect.set(array,1,20);

console.log(obj);  // {name: '柏拉图'}
console.log(array); //  [empty, 20]

十三、Reflect.setPrototypeOf()

静态方法**Reflect.setPrototypeOf()与Object.setPrototypeOf()**方法是一样的。它可设置对象的原型（即内部的 [[Prototype]] 属性）为另一个对象或 null，如果操作成功返回 true，否则返回 false。如果 target 不是 Object ，或 prototype 既不是对象也不是 null，抛出一个 TypeError 异常。

语法

Reflect.setPrototypeOf(target, prototype)

target: 设置原型的目标对象
prototype: 对象的新原型（一个对象或 null）。

返回值

返回一个 Boolean 值表明是否原型已经成功设置。

应用场景

通过Object.setPrototypeOf()或者Reflect.setPrototypeOf()设置对象原型

通过 Object.setPrototypeOf() 设置对象原型
const obj = {}

const result = Object.setPrototypeOf(obj,{name:'obj的原型'});

console.log(result); // {}
console.log(obj.__proto__);  // {name: 'obj的原型'}

通过 Reflect.setPrototypeOf() 设置对象原型
const obj = {}
const result = Reflect.setPrototypeOf(obj,{name:'obj的原型'});

console.log(result); // true
console.log(obj.__proto__);  // {name: 'obj的原型'}

一、Reflect.apply()​

二、Reflect.construct()​

三、Reflect.defineProperty()​

四、Reflect.deleteProperty()​

五、Reflect.get()​

六、Reflect.getOwnPropertyDescriptor()​

七、Reflect.getPrototypeOf()​

八、Reflect.has()​

九、Reflect.isExtensible()​

十、Reflect.ownKeys()​

十一、Reflect.preventExtensions()​

十二、Reflect.set()​

十三、Reflect.setPrototypeOf()​

一、Reflect.apply()

二、Reflect.construct()

三、Reflect.defineProperty()

四、Reflect.deleteProperty()

五、Reflect.get()

六、Reflect.getOwnPropertyDescriptor()

七、Reflect.getPrototypeOf()

八、Reflect.has()

九、Reflect.isExtensible()

十、Reflect.ownKeys()

十一、Reflect.preventExtensions()

十二、Reflect.set()

十三、Reflect.setPrototypeOf()