proxy的使用
- Proxy 构造器在整个全局对象上都可以被访问
深入了解以前，有三个词你需要先了解下 : target, handler, 以及 trap
target 指的是代理所代表的对象。它就是那个你想要节制对其访问的对象。它总是被作为 Proxy构造器的第一个参数传入，并且也会被传入每个 trap 中(更多关于这个的内容在后面两行)。
handler 是一个对象，包含了你想要拦截和处理的操作。它被作为 Proxy 构造器的第二个参数传入。它实现了 Proxy API (例如：get, set, apply 等等)。
trap 是指代 handler 中处理特定方法的一个方法项。因此如果你要拦截对 get 方法的调用，就要定义一个 get 的 trap，诸如此类。
Reflect使用
-
Reflect 是一个内置的对象，它提供拦截 JavaScript 操作的方法。这些方法与处理器对象的方法相同。
Reflect不是一个函数对象，因此它是不可构造的。 - 描述： 与大多数全局对象不同，
Reflect没有构造函数。你不能将其与一个new运算符一起使用，或者将Reflect对象作为一个函数来调用。Reflect的所有属性和方法都是静态的（就像Math对象）。 - 方法
Reflect.apply(target, thisArgument, argumentsList)
target
目标函数。
thisArgument
target函数调用时绑定的this对象。
argumentsList
target函数调用时传入的实参列表，该参数应该是一个类数组的对象。
Reflect.construct(target, argumentsList[, newTarget])
var obj = new Foo(...args);
var obj = Reflect.construct(Foo, args);
Reflect.defineProperty(target, propertyKey, attributes)
const student = {};
Reflect.defineProperty(student, "name", {value: "Mike"}); // true
student.name; // "Mike"
Reflect.deleteProperty(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"); // false
Reflect.get(target, propertyKey[, receiver])
// Object
var obj = { x: 1, y: 2 };
Reflect.get(obj, "x"); // 1
// Array
Reflect.get(["zero", "one"], 1); // "one"
// 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(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, writable: true, enumerable: false, configurable: false}
Reflect.getPrototypeOf(target)
Reflect.getPrototypeOf 返回指定对象的原型
Reflect.getPrototypeOf({}); // Object.prototype
Reflect.getPrototypeOf(Object.prototype); // null
Reflect.getPrototypeOf(Object.create(null)); // null
Reflect.has(target, propertyKey)
`Reflect.has` 用于检查一个对象是否拥有某个属性， 相当于[`in` 操作符]
Reflect.has({x: 0}, "x"); // true
Reflect.has({x: 0}, "y"); // false
// 如果该属性存在于原型链中，返回true
Reflect.has({x: 0}, "toString");
// Proxy 对象的 .has() 句柄方法
obj = new Proxy({}, {
has(t, k) { return k.startsWith("door"); }
});
Reflect.has(obj, "doorbell"); // true
Reflect.has(obj, "dormitory"); // false
Reflect.isExtensible(target)
Reflect.isExtensible 判断一个对象是否可扩展 （即是否能够添加新的属性）
// New objects are extensible.
var empty = {};
Reflect.isExtensible(empty); // === true
// ...but that can be changed.
Reflect.preventExtensions(empty);
Reflect.isExtensible(empty); // === false
// Sealed objects are by definition non-extensible.
var sealed = Object.seal({});
Reflect.isExtensible(sealed); // === false
// Frozen objects are also by definition non-extensible.
var frozen = Object.freeze({});
Reflect.isExtensible(frozen); // === false
如果该方法的第一个参数不是一个对象（原始值），那么将造成一个 [`TypeError`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/TypeError "TypeError（类型错误） 对象用来表示值的类型非预期类型时发生的错误。") 异常。对于 [`Object.isExtensible()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible "Object.isExtensible() 方法判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。")，非对象的第一个参数会被强制转换为一个对象。
静态方法 Reflect.ownKeys()
返回一个由目标对象自身的属性键组成的数组。
const object1 = {
property1: 42,
property2: 13
};
var array1 = [];
console.log(Reflect.ownKeys(object1));
// expected output: Array ["property1", "property2"]
console.log(Reflect.ownKeys(array1));
// expected output: Array ["length"]
Reflect.set(target, propertyKey, value[, receiver])
// 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, configurable: true }
Reflect.setPrototypeOf(target, prototype)
静态方法 `**Reflect**`**`.setPrototypeOf()`** 与 [`Object.setPrototypeOf()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf "如果对象的[[Prototype]]被修改成不可扩展(通过 Object.isExtensible()查看)，就会抛出 TypeError异常。如果prototype参数不是一个对象或者null(例如，数字，字符串，boolean，或者 undefined)，则什么都不做。否则，该方法将obj的[[Prototype]]修改为新的值。") 方法是一致的。它将指定对象的原型 （即，内部的`[[Prototype]] `属性）设置为另一个对象或为 [`null`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/null "值 null 特指对象的值未设置。它是 JavaScript 基本类型 之一。")。
Reflect.setPrototypeOf({}, Object.prototype); // true
// It can change an object's [[Prototype]] to null.
Reflect.setPrototypeOf({}, null); // true
// Returns false if target is not extensible.
Reflect.setPrototypeOf(Object.freeze({}), null); // false
// Returns false if it cause a prototype chain cycle.
var target = {};
var proto = Object.create(target);
Reflect.setPrototypeOf(target, proto); // false
Reflect.preventExtensions(target)
静态方法 Reflect.preventExtensions() 方法阻止新属性添加到对象
网友评论