me

Reflect


Reflect

Reflect.apply()

过指定的参数列表发起对目标 (target) 函数的调用

Reflect.apply(RegExp.prototype.test, /ab/, ["confabulation"]);
//true

Reflect.construct()

类似于 new 操作符构造函数,相当于运行new target(...args)

function OneClass() {
  this.name = "one";
}

function OtherClass() {
  this.name = "other";
}

// 创建一个对象:
const obj1 = Reflect.construct(OneClass, args, OtherClass);

// 与上述方法等效:
const obj2 = Object.create(OtherClass.prototype);
OneClass.apply(obj2, args);

Reflect.defineProperty()

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

let obj = { "x": 2 };
Reflect.defineProperty(obj, "y", { value: 7 }); // true
console.log(obj); //{x: 2, y: 7}

Reflect.deleteProperty()

用于删除属性。类似delete operator但它是一个函数

const obj = { x: 1, y: 2 };
Reflect.deleteProperty(obj, "x"); // true
obj; // { y: 2 }

Reflect.has()

Reflect.has(target, propertyKey)作用与 in 操作符相同

//如果该属性存在于原型链中,返回 true
Reflect.has({ x: 0 }, "toString");

// Proxy 对象的 .has() 句柄方法
const obj = new Proxy({}, {
  has(t, k) {
    return k.startsWith("door");
  },
});
Reflect.has(obj, "doorbell"); // true

Reflect.get()

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

const x = { p: 1 };
const obj = new Proxy(x, {
  get(t, k, r) {
    return k + "bar";
  },
});
Reflect.get(obj, "foo"); // "foobar"

Reflect.set()

在一个对象上设置一个属性

const obj = {};
Reflect.set(obj, "prop", "value"); // true
obj.prop; // "value"

Reflect.getOwnPropertyDescriptor()

如果属性在对象中存在,则返回给定的属性的属性描述符。否则返回undefined

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

Reflect.getPrototypeOf()

返回指定对象的原型

Reflect.getPrototypeOf({});
// Object.prototype

Reflect.setPrototypeOf()

它可设置对象的原型 (即内部的[[Prototype]]属性) 为另一个对象或 null,如果操作成功返回 true,否则返回 false

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

Reflect.isExtensible()

判断一个对象是否可扩展 (即是否能够添加新的属性)

const frozen = Object.freeze({});
Reflect.isExtensible(frozen); //false

Reflect.ownKeys()

返回一个由目标对象自身的属性键组成的数组

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

Reflect.preventExtensions()

阻止新属性添加到对象 (例如:防止将来对对象的扩展被添加到对象中)

const empty = {};
Reflect.isExtensible(empty); //true
Reflect.preventExtensions(empty);
Reflect.isExtensible(empty); //false