javascript中Reflect內(nèi)置對象的示例分析

小編給大家分享一下javascript中Reflect內(nèi)置對象的示例分析，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

語義

Reflect是一個(gè)內(nèi)置的對象，它提供攔截JavaScript操作的方法。這些方法與處理器對象的方法相同。Reflect不是一個(gè)函數(shù)對象，因此它是不可構(gòu)造的。

描述

與大多數(shù)全局對象不同，Reflect沒有構(gòu)造函數(shù)。你不能將其與一個(gè)new運(yùn)算符一起使用，或者將Reflect對象作為一個(gè)函數(shù)來調(diào)用。Reflect的所有屬性和方法都是靜態(tài)的（就像 Math 對象）。

兼容性

Chrome：49+

Firefox (Gecko)：42+

其他瀏覽器暫未實(shí)現(xiàn)

句法

Reflect.apply(target, thisArgument, argumentsList)

參數(shù)

target

目標(biāo)函數(shù)。

thisArgument target

函數(shù)調(diào)用時(shí)綁定的this對象。

argumentsList

target函數(shù)調(diào)用時(shí)傳入的實(shí)參列表，該參數(shù)應(yīng)該是一個(gè)類數(shù)組的對象。

方法

Reflect.apply()

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

靜態(tài)方法Reflect.apply()通過指定的參數(shù)列表發(fā)起對目標(biāo)(target)函數(shù)的調(diào)用。

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()方法的行為有點(diǎn)像new操作符 構(gòu)造函數(shù) ， 相當(dāng)于運(yùn)行new target(...args)。

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

Reflect.defineProperty()

Reflect.defineProperty()是一個(gè)靜態(tài)的方法，看起來像Object.defineProperty()但是它返回一個(gè)布爾值

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: 42

Reflect.deleteProperty()

靜態(tài)方法Reflect.deleteProperty()允許用于刪除屬性。它很像delete operator，但它是一個(gè)函數(shù)。Reflect.deleteProperty允許你刪除一個(gè)對象上的屬性。返回一個(gè)Boolean值表示該屬性是否被成功刪除。它幾乎與非嚴(yán)格的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"); // false

Reflect.get()

Reflect.get()方法的工作方式，就像從object (target[propertyKey])中獲取屬性，但它是作為一個(gè)函數(shù)執(zhí)行的。

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()

靜態(tài)方法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()

靜態(tài)方法Reflect.getPrototypeOf()與Object.getPrototypeOf()方法是一樣的。都是返回指定對象的原型（即，內(nèi)部的 [[Prototype]] 屬性的值）。

Reflect.getPrototypeOf(target)

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

Reflect.has()

靜態(tài)方法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"); // false

Reflect.isExtensible()

靜態(tài)方法Reflect.isExtensible()判斷一個(gè)對象是否可擴(kuò)展 （即是否能夠添加新的屬性）。與它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);
// false

Reflect.ownKeys()

靜態(tài)方法Reflect.ownKeys()返回一個(gè)由目標(biāo)對象自身的屬性鍵組成的數(shù)組。

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 order

Reflect.preventExtensions()

靜態(tài)方法Reflect.preventExtensions()方法阻止新屬性添加到對象例如：防止將來對對象的擴(kuò)展被添加到對象中)。該方法與Object.preventExtensions()相似，但有一些不同點(diǎn)。

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()

靜態(tài)方法Reflect.set()工作方式就像在一個(gè)對象上設(shè)置一個(gè)屬性。

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()

靜態(tài)方法Reflect.setPrototypeOf()與Object.setPrototypeOf()方法是一致的。它將指定對象的原型 （即，內(nèi)部的[[Prototype]] 屬性）設(shè)置為另一個(gè)對象或?yàn)?code>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中Reflect內(nèi)置對象的示例分析”這篇文章的所有內(nèi)容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內(nèi)容對大家有所幫助，如果還想學(xué)習(xí)更多知識，歡迎關(guān)注億速云行業(yè)資訊頻道！