Die statische MethodeReflect.construct() ist wie dernew Operator, aber als Funktion. Sie ist gleichbedeutend mit dem Aufruf vonnew target(...args). Zusätzlich ermöglicht es die Angabe eines anderennew.target-Werts.

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: 6console.log(object1.sum);// Expected output: 6

Syntax

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

Parameter

target

Die Zielfunktion, die aufgerufen werden soll.

argumentsList

Einarray-ähnliches Objekt, das die Argumente angibt, mit denentarget aufgerufen werden soll.

newTargetOptional

Der Wert desnew.target-Ausdrucks innerhalb vontarget. Standardmäßigtarget. Im Allgemeinen (siehe Beispiel) gibttarget dieLogik zur Initialisierung des Objekts an, währendnewTarget.prototype dasPrototyp des konstruierten Objekts spezifiziert.

Rückgabewert

Eine neue Instanz vontarget (odernewTarget, falls vorhanden), initialisiert durchtarget als Konstruktor mit der angegebenenargumentsList.

Ausnahmen

TypeError

Wird ausgelöst, wenntarget odernewTarget kein Konstruktor ist, oder wennargumentsList kein Objekt ist.

Beschreibung

Reflect.construct() bietet die reflektive Semantik eines Konstruktoraufrufs. Das heißt,Reflect.construct(target, argumentsList, newTarget) ist semantisch gleichbedeutend mit:

new target(...argumentsList);

Beachten Sie, dass bei Verwendung desnew Operatorstarget undnewTarget immer derselbe Konstruktor sind — aberReflect.construct() ermöglicht es, einen anderennew.target-Wert zu übergeben. Konzeptionell istnewTarget die Funktion, bei dernew aufgerufen wurde, undnewTarget.prototype wird das Prototyp des konstruierten Objekts; währendtarget der Konstruktor ist, der tatsächlich ausgeführt wird, um das Objekt zu initialisieren. Zum Beispiel kannnew.target auch anders sein als der aktuell ausgeführte Konstruktor bei der Vererbung von Klassen.

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

Reflect.construct() ermöglicht es Ihnen, einen Konstruktor mit einer variablen Anzahl von Argumenten aufzurufen. (Dies ist auch mit derSpread-Syntax bei einem normalen Konstruktoraufruf möglich.)

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

Reflect.construct() ruft die[[Construct]]interne Objektmethode vontarget auf.

Beispiele

Verwendung von Reflect.construct()

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

Ändern von new.target

WennnewTarget übergeben wird, ändert sich der Wert vonnew.target im Konstruktor. Das konstruierte Objekt wird eine Instanz vonnewTarget sein, nichttarget.

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 OneClassconsole.log(obj1 instanceof OneClass); // trueconst obj2 = Reflect.construct(OneClass, [], OtherClass);// Logs:// OneClass executed// new.target is OtherClassconsole.log(obj2 instanceof OtherClass); // trueconsole.log(obj2 instanceof OneClass); // false

Natürlich gibt es keine starke Garantie über die Prototypkette des konstruierten Objekts, da dies von der Implementierung des Konstruktors abhängt. Zum Beispiel, wenn dertarget Konstruktor ein Objekt zurückgibt, dann wird dieses Objekt das konstruierte Objekt sein, unabhängig vomnewTarget Wert. Wenntarget ein Proxy mit einerconstruct Falle ist, dann kontrolliert die Falle vollständig 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); // falseconsole.log(obj1 instanceof OtherClass); // false

Ein gültigesnew.target sollte eine Konstruktorfunktion mit einerprototype-Eigenschaft sein, aber letzteres wird nicht erzwungen. Wenn der Wert derprototype Eigenschaft kein Objekt ist, erbt das initialisierte Objekt vonObject.prototype.

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 OtherClassconsole.log(Object.getPrototypeOf(obj) === Object.prototype); // true

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

Vor der Einführung vonReflect konnten Objekte mit einer beliebigen Kombination von Konstruktoren und Prototypen unter Verwendung vonObject.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); // falseconsole.log(obj2 instanceof OneClass); // falseconsole.log(obj1 instanceof OtherClass); // trueconsole.log(obj2 instanceof OtherClass); // true

Obwohl das Endergebnis dasselbe ist, gibt es einen wichtigen Unterschied im Prozess. Bei der Verwendung vonObject.create() undFunction.prototype.apply() zeigt dernew.target Operator innerhalb der Funktion, die als Konstruktor verwendet wird, aufundefined, da dasnew Schlüsselwort nicht verwendet wird, um das Objekt zu erstellen. (Tatsächlich verwendet es dieapply-Semantik, nichtconstruct, obwohl normale Funktionen fast gleich funktionieren.)

Beim Aufruf vonReflect.construct() hingegen zeigt dernew.target Operator auf dennewTarget Parameter, falls angegeben, oder auftarget, wenn 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-Kompatibilität

Siehe auch

• Polyfill vonReflect.construct incore-js
• Reflect
• new
• new.target
• handler.construct()