Reflect.construct()

Probieren Sie es aus

function func1(a, b, c) {
  this.sum = a + b + c;
}

const args = [1, 2, 3];
const object1 = new func1(...args);
const object2 = Reflect.construct(func1, args);

console.log(object2.sum);
// Expected output: 6

console.log(object1.sum);
// Expected output: 6

Syntax

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

Parameter

target

Die Ziel-Funktion, die aufgerufen werden soll.

argumentsList

Ein array-hnliches Objekt, das die Argumente spezifiziert, mit denen target aufgerufen werden soll.

newTarget Optional

Der Wert des Ausdrucks new.target innerhalb von target. Standardmig target. Im Allgemeinen (sehen Sie das Beispiel) spezifiziert target die Logik zur Initialisierung des Objekts, whrend newTarget.prototype das Prototyp des konstruierten Objekts angibt.

Rckgabewert

Eine neue Instanz von target (oder newTarget, falls vorhanden), initialisiert durch target als Konstruktor mit der angegebenen argumentsList.

Ausnahmen

TypeError

Wird ausgelst, wenn target oder newTarget kein Konstruktor ist oder wenn argumentsList kein Objekt ist.

Beschreibung

Reflect.construct() bietet die reflektive Semantik eines Konstruktoraufrufs. Das heit, Reflect.construct(target, argumentsList, newTarget) ist semantisch quivalent zu:

new target(...argumentsList);

Beachten Sie, dass bei Verwendung des new Operators target und newTarget immer der gleiche Konstruktor sind aber Reflect.construct() ermglicht es Ihnen, einen anderen Wert fr new.target zu bergeben. Konzeptionell ist newTarget die Funktion, auf der new aufgerufen wurde, und newTarget.prototype wird zum Prototyp des konstruierten Objekts, whrend target der tatschlich ausgefhrte Konstruktor zur Initialisierung des Objekts ist. Zum Beispiel kann new.target auch von dem derzeit ausgefhrten Konstruktor in der Klassenvererbung abweichen.

class A {
  constructor() {
    console.log(new.target.name);
  }
}
class B extends A {}

new B(); // "B"

Reflect.construct() ermglicht es Ihnen, einen Konstruktor mit einer variablen Anzahl von Argumenten aufzurufen. (Dies ist auch mit der Spread-Syntax in einem normalen Konstruktoraufruf mglich.)

const obj = new Foo(...args);
const obj = Reflect.construct(Foo, args);

Reflect.construct() ruft die [[Construct]] interne Methode des Objekts von target auf.

Beispiele

Verwendung von Reflect.construct()

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

nderung von new.target

Wenn newTarget bergeben wird, ndert sich der Wert von new.target innerhalb des Konstruktors. Das konstruierte Objekt wird eine Instanz von newTarget, nicht target.

function OneClass() {
  console.log("OneClass executed");
  console.log(`new.target is ${new.target.name}`);
}

function OtherClass() {
  console.log("OtherClass executed");
  console.log(`new.target is ${new.target.name}`);
}

const obj1 = Reflect.construct(OneClass, []);
// Logs:
// OneClass executed
// new.target is OneClass
console.log(obj1 instanceof OneClass); // true

const obj2 = Reflect.construct(OneClass, [], OtherClass);
// Logs:
// OneClass executed
// new.target is OtherClass
console.log(obj2 instanceof OtherClass); // true
console.log(obj2 instanceof OneClass); // false

Natrlich gibt es keine starke Garantie ber die Prototyp-Kette des konstruierten Objekts, da dies von der Implementierung des Konstruktors abhngt. Zum Beispiel, wenn der target Konstruktor ein Objekt zurckgibt, dann wird dieses Objekt das konstruierte Objekt sein, unabhngig vom Wert von newTarget. Wenn target ein Proxy mit einer construct Falle ist, dann kontrolliert die Falle vollstndig den Konstruktionsprozess.

function OneClass() {
  return { name: "one" };
}

function OtherClass() {
  return { name: "other" };
}

const obj1 = Reflect.construct(OneClass, [], OtherClass);
console.log(obj1.name); // 'one'
console.log(obj1 instanceof OneClass); // false
console.log(obj1 instanceof OtherClass); // false

Ein gltiges new.target sollte eine Konstruktorfunktion mit einer prototype Eigenschaft sein, aber letzteres wird nicht erzwungen. Wenn der Wert der prototype Eigenschaft kein Objekt ist, wird das initialisierte Objekt von Object.prototype erben.

function OneClass() {
  console.log("OneClass executed");
  console.log(`new.target is ${new.target.name}`);
}

function OtherClass() {
  console.log("OtherClass executed");
  console.log(`new.target is ${new.target.name}`);
}

OtherClass.prototype = null;

const obj = Reflect.construct(OneClass, [], OtherClass);
// Logs:
// OneClass executed
// new.target is OtherClass
console.log(Object.getPrototypeOf(obj) === Object.prototype); // true

Reflect.construct() vs. Object.create()

Vor der Einfhrung von Reflect konnten Objekte mit einer beliebigen Kombination von Konstruktoren und Prototypen unter Verwendung von Object.create() konstruiert werden.

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

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

const args = [];
const obj1 = Reflect.construct(OneClass, args, OtherClass);
const obj2 = Object.create(OtherClass.prototype);
OneClass.apply(obj2, args);

console.log(obj1.name); // 'one'
console.log(obj2.name); // 'one'

console.log(obj1 instanceof OneClass); // false
console.log(obj2 instanceof OneClass); // false

console.log(obj1 instanceof OtherClass); // true
console.log(obj2 instanceof OtherClass); // true

Whrend das Endergebnis dasselbe ist, gibt es einen wichtigen Unterschied im Prozess. Bei Verwendung von Object.create() und Function.prototype.apply() wird der new.target Operator innerhalb der als Konstruktor verwendeten Funktion auf undefined zeigen, da das new Schlsselwort nicht zum Erstellen des Objekts verwendet wird. (Tatschlich verwendet es die apply Semantik, nicht construct, obwohl normale Funktionen nahezu gleich funktionieren.)

Beim Aufruf von Reflect.construct() hingegen zeigt der new.target Operator auf den newTarget Parameter, falls angegeben, oder auf target, falls nicht.

function OneClass() {
  console.log("OneClass");
  console.log(new.target);
}
function OtherClass() {
  console.log("OtherClass");
  console.log(new.target);
}

const obj1 = Reflect.construct(OneClass, args);
// Logs:
// OneClass
// function OneClass { ... }

const obj2 = Reflect.construct(OneClass, args, OtherClass);
// Logs:
// OneClass
// function OtherClass { ... }

const obj3 = Object.create(OtherClass.prototype);
OneClass.apply(obj3, args);
// Output:
//     OneClass
//     undefined

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Polyfill von Reflect.construct in core-js
• Reflect
• new
• new.target
• handler.construct()