Analisis ringkas objek terbina dalam Reflect dalam JavaScript (penjelasan kod terperinci)

Dalam artikel sebelumnya "Menjelaskan penukaran penghalaan untuk menamatkan permintaan tak segerak dalam Vue (dengan kod) ", saya memperkenalkan anda kepada penukaran penghalaan untuk menamatkan permintaan tak segerak dalam Vue. Artikel berikut akan membantu anda memahami objek terbina dalam Reflect dalam js Ia mempunyai nilai rujukan tertentu, saya harap ia akan membantu anda.

Semantik

Reflect ialah objek terbina dalam yang menyediakan kaedah untuk memintas operasi JavaScript. Kaedah ini adalah sama dengan kaedah objek pemproses. Reflect bukan objek fungsi, jadi ia tidak boleh dibina.

Penerangan

Tidak seperti kebanyakan objek global, Reflect tidak mempunyai pembina. Anda tidak boleh menggunakannya dengan pengendali new atau memanggil objek Reflect sebagai fungsi. Semua sifat dan kaedah Reflect adalah statik (sama seperti objek Math).

Keserasian

Chrome: 49

Firefox (Gecko): 42

Pelayar lain belum melaksanakannya lagi

Sintaks

Reflect.apply(target, thisArgument, argumentsList)

Parameter

target

Fungsi sasaran.

thisArgument target

Objek this terikat apabila fungsi dipanggil.

argumentsList

Senarai parameter sebenar yang dihantar apabila fungsi sasaran dipanggil Parameter ini mestilah objek seperti tatasusunan.

Kaedah

Reflect.apply()

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

Kaedah statik Reflect.apply() memulakan panggilan ke fungsi sasaran (target) dengan senarai parameter yang ditentukan. Kaedah

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() berkelakuan sedikit seperti pembina operator baharu, yang bersamaan dengan menjalankan new target(...args).

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

Reflect.defineProperty()

Reflect.defineProperty() ialah kaedah statik yang kelihatan seperti Object.defineProperty() tetapi ia mengembalikan nilai Boolean

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

Kaedah statik Reflect.deleteProperty() membenarkan pemadaman sifat. Ia sama seperti delete operator, tetapi ia adalah satu fungsi. Reflect.deletePropertyMembolehkan anda memadamkan atribut pada objek. Mengembalikan nilai Boolean yang menunjukkan sama ada atribut berjaya dipadamkan. Ia hampir sama dengan pengendali padam yang tidak ketat.

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() kaedah berfungsi seperti mendapatkan atribut daripada object (target[propertyKey]), tetapi ia dilakukan sebagai fungsi.

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

Kaedah statik Reflect.getOwnPropertyDescriptor()与Object.getOwnPropertyDescriptor() adalah serupa. Mengembalikan deskriptor sifat bagi harta yang diberikan, jika terdapat dalam objek. Jika tidak, undefined dikembalikan.

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

Kaedah statikReflect.getPrototypeOf()与Object.getPrototypeOf() >Caranya adalah sama. Kedua-duanya mengembalikan prototaip objek yang ditentukan (iaitu, nilai atribut [[Prototype]] dalaman).

Reflect.getPrototypeOf(target)

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

Reflect.has()

Kaedah statikReflect.has()Fungsi Sama seperti operator 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()

Kaedah statikReflect.isExtensible()Tentukan sama ada objek boleh dipanjangkan (iaitu, sama ada sifat baharu boleh ditambah). Sama seperti kaedah Object.isExtensible()nya, tetapi dengan beberapa perbezaan, lihat differences untuk mendapatkan butiran.

Reflect.isExtensible(sasaran)

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

Kaedah statikReflect.ownKeys()Kembali Tatasusunan yang terdiri daripada kunci sifat objek sasaran itu sendiri.

Reflect.ownKeys(sasaran)

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

kaedah statikReflect.preventExtensions()kaedah Halang sifat baharu daripada ditambahkan pada objek (cth. halang sambungan masa hadapan pada objek daripada ditambahkan pada objek). Kaedah ini serupa dengan Object.preventExtensions(), tetapi mempunyai beberapa perbezaan.

Reflect.preventExtensions(sasaran)

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

kaedah statikReflect.set() berfungsi Kaedahnya adalah seperti menetapkan sifat pada objek.

Reflect.set(sasaran, propertyKey, nilai[, penerima])

// 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视频教程

Atas ialah kandungan terperinci Analisis ringkas objek terbina dalam Reflect dalam JavaScript (penjelasan kod terperinci). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!