在
之前的文章《一文講解Vue中路由切換終止異步請求（附代碼）》中，給大家介紹了解了vue中路由切換終止異步請求。以下這篇文章給大家了解js中Reflect內建對象，有一定的參考價值，有需要的朋友可以參考一下，希望對你們有所助。
Reflect是內建的對象，它提供攔截JavaScript操作的方法。這些方法與處理器物件的方法相同。 Reflect不是函數對象，因此它是不可建構的。
與大多數全域物件不同，Reflect沒有建構子。你不能將其與一個new運算子一起使用，或將Reflect物件作為一個函數來呼叫。 Reflect的所有屬性和方法都是靜態的（就像 Math 物件）。
Chrome：49
Firefox (Gecko)：42
其他瀏覽器暫未實作
Reflect.apply(target, thisArgument, argumentsList)
target
目標函數。
thisArgument
target
函數呼叫時綁定的this物件。
argumentsList
target函數呼叫時傳入的實參列表，該參數應該是一個類別數組的物件。
Reflect.apply()
#Reflect.construct(target, argumentsList[, newTarget])
靜態方法Reflect.apply()透過指定的參數清單發起對目標(target)函數的呼叫。
Reflect.apply(Math.floor, undefined, [1.75]);
// 1;
Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]);
// "hello"
Reflect.apply(RegExp.prototype.exec, /ab/, ["confabulation"]).index;
// 4
Reflect.apply("".charAt, "ponies", [3]);
// "i"Reflect.construct()
#Reflect.construct()方法的行為有點像new運算子建構函數， 相當於執行 new target(...args)。
var d = Reflect.construct(Date, [1776, 6, 4]); d instanceof Date; // true d.getFullYear(); // 1776
Reflect.defineProperty()
Reflect.defineProperty()是一個靜態的方法，看起來像Object.defineProperty ()但是它傳回一個布林值
const object1 = {};
if (Reflect.defineProperty(object1, "property1", { value: 42 })) {
console.log("property1 created!");
// expected output: "property1 created!"
} else {
console.log("problem creating property1");
}
console.log(object1.property1);
// expected output: 42Reflect.deleteProperty()
靜態方法Reflect.deleteProperty()允許用於刪除屬性。它很像delete operator，但它是一個函數。 Reflect.deleteProperty允許你刪除一個物件上的屬性。傳回一個Boolean值表示該屬性是否被成功刪除。它幾乎與非嚴格的delete operator相同。
#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"); // falseReflect.get()
Reflect.get ()方法的工作方式，就像從object (target[propertyKey])中取得屬性，但它是作為一個函數執行的。
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()
靜態方法Reflect.getOwnPropertyDescriptor()與Object.getOwnPropertyDescriptor()方法相似。如果在物件中存在，則傳回給定的屬性的屬性描述符。否則返回 undefined。
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()
靜態方法Reflect .getPrototypeOf()與Object.getPrototypeOf()方法是一樣的。都是傳回指定物件的原型（即，內部的 [[Prototype]] 屬性的值）。
Reflect.getPrototypeOf(target)
Reflect.getPrototypeOf({}); // Object.prototype
Reflect.getPrototypeOf(Object.prototype); // null
Reflect.getPrototypeOf(Object.create(null)); // nullReflect.has()
靜態方法Reflect.has ()作用與in運算子相同。
Reflect.has(target, propertyKey)
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"); // falseReflect.isExtensible()
# 靜態方法Reflect .isExtensible()判斷一個物件是否可擴展（即是否能夠新增新的屬性）。與它Object.isExtensible()方法相似，但有些不同，詳情可見differences。
Reflect.isExtensible(target)
// 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
//diff Object.isExtensible
Reflect.isExtensible(1);
// TypeError: 1 is not an object
Object.isExtensible(1);
// falseReflect.ownKeys()
靜態方法Reflect.ownKeys ()傳回一個由目標物件本身的屬性鍵所組成的陣列。
Reflect.ownKeys(target)
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.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 = {
[sym]: 0,
str: 0,
"773": 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) ]
// Indexes in numeric order,
// strings in insertion order,
// symbols in insertion orderReflect.preventExtensions()
##靜態方法Reflect.preventExtensions ()方法阻止新屬性加入到物件例如：防止將來對物件的擴充被加入到物件中)。此方法與Object.preventExtensions()相似，但有些不同點。
Reflect.preventExtensions(target)// Objects are extensible by default. var empty = {}; Reflect.isExtensible(empty); // === true // ...but that can be changed. Reflect.preventExtensions(empty); Reflect.isExtensible(empty); // === false //diff Object.preventExtensions() Reflect.preventExtensions(1); // TypeError: 1 is not an object Object.preventExtensions(1); // 1登入後複製
Reflect.set()
靜態方法Reflect.set ()工作方式就像在一個物件上設定一個屬性。
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()
静态方法Reflect.setPrototypeOf()与Object.setPrototypeOf()方法是一致的。它将指定对象的原型 （即，内部的[[Prototype]] 属性）设置为另一个对象或为null。
Reflect.setPrototypeOf(target, prototype)
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推荐学习：JavaScript视频教程
以上是淺析javascript中Reflect內建物件（程式碼詳解）的詳細內容。更多資訊請關注PHP中文網其他相關文章！
