Dienew.target Meta-Eigenschaft ermöglicht es Ihnen zu erkennen, ob eine Funktion oder ein Konstruktor mit demnew Operator aufgerufen wurde. In Konstruktoren und Funktionen, die mit demnew Operator aufgerufen wurden, gibtnew.target eine Referenz auf den Konstruktor oder die Funktion zurück, auf dienew angewendet wurde. Bei normalen Funktionsaufrufen istnew.targetundefined.

Probieren Sie es aus

function Foo() {  if (!new.target) {    throw new TypeError("calling Foo constructor without new is invalid");  }}try {  Foo();} catch (e) {  console.log(e);  // Expected output: TypeError: calling Foo constructor without new is invalid}

Syntax

new.target

Wert

new.target ist garantiert ein konstruierbarer Funktionswert oderundefined.

• In Klassenkonstruktoren bezieht es sich auf die Klasse, auf dienew angewendet wurde, was eine Unterklasse des aktuellen Konstruktors sein kann, da Unterklassen transitiv den Konstruktor der Superklasse übersuper() aufrufen.
• In normalen Funktionen, wenn die Funktion direkt mitnew konstruiert wird, bezieht sichnew.target auf die Funktion selbst. Wird die Funktion ohnenew aufgerufen, istnew.targetundefined. Funktionen können als Basisklasse fürextends verwendet werden, in diesem Fall kann sichnew.target auf die Unterklasse beziehen.
• Wenn ein Konstruktor (Klasse oder Funktion) überReflect.construct() aufgerufen wird, bezieht sichnew.target auf den Wert, der alsnewTarget übergeben wurde (der standardmäßigtarget ist).
• Inarrow functions wirdnew.target aus dem umgebenden Kontext geerbt. Wenn die Pfeilfunktion nicht innerhalb einer anderen Klasse oder Funktion definiert ist, die einenew.targetBindung hat, wird ein Syntaxfehler ausgelöst.
• Instatischen Initialisierungsblöcken istnew.targetundefined.

Beschreibung

Dienew.target Syntax besteht aus dem Schlüsselwortnew, einem Punkt und dem Bezeichnertarget. Danew einreserviertes Wort ist und kein Bezeichner, handelt es sich hierbei nicht um einenProperty-Accessor, sondern um eine spezielle Ausdruckssyntax.

Dienew.target Meta-Eigenschaft ist in allen Funktions-/Klassenkörpern verfügbar; die Verwendung vonnew.target außerhalb von Funktionen oder Klassen führt zu einem Syntaxfehler.

Beispiele

new.target in Funktionsaufrufen

Bei normalen Funktionsaufrufen (im Gegensatz zu Konstruktionsaufrufen von Funktionen) istnew.targetundefined. Dies ermöglicht es Ihnen zu erkennen, ob eine Funktion mitnew als Konstruktor aufgerufen wurde.

function Foo() {  if (!new.target) {    throw new Error("Foo() must be called with new");  }  console.log("Foo instantiated with new");}new Foo(); // Logs "Foo instantiated with new"Foo(); // Throws "Foo() must be called with new"

new.target in Konstruktoren

In Klassenkonstruktoren bezieht sichnew.target auf den Konstruktor, der direkt vonnew aufgerufen wurde. Dies ist auch der Fall, wenn der Konstruktor in einer Elternklasse ist und von einem Kinderkonstruktor delegiert wurde.new.target zeigt auf die Klasse, auf dienew angewendet wurde. Zum Beispiel wurde bei der Initialisierung vonb mitnew B() der Name vonB ausgegeben; und ähnlich im Fall vona, wurde der Name der KlasseA ausgegeben.

class A {  constructor() {    console.log(new.target.name);  }}class B extends A {  constructor() {    super();  }}const a = new A(); // Logs "A"const b = new B(); // Logs "B"

new.target unter Verwendung von Reflect.construct()

VorReflect.construct() oder Klassen war es üblich, Vererbung zu implementieren, indem der Wert vonthis übergeben und der Basiskonstruktor modifiziert wurde.

function Base() {  this.name = "Base";}function Extended() {  // Only way to make the Base() constructor work on the existing  // `this` value instead of a new object that `new` creates.  Base.call(this);  this.otherProperty = "Extended";}Object.setPrototypeOf(Extended.prototype, Base.prototype);Object.setPrototypeOf(Extended, Base);console.log(new Extended()); // Extended { name: 'Base', otherProperty: 'Extended' }

Allerdings rufencall() undapply() die Funktion tatsächlichauf, anstatt sie zukonstruieren, daher hatnew.target den Wertundefined. Dies bedeutet, dass, wennBase() überprüft, ob es mitnew konstruiert wurde, ein Fehler ausgelöst wird, oder es kann auf andere unerwartete Weise verhalten werden. Zum Beispiel können SieMap nicht auf diese Weise erweitern, da derMap() Konstruktor nicht ohnenew aufgerufen werden kann.

Alle eingebauten Konstruktoren konstruieren direkt die gesamte Prototypenkette der neuen Instanz, indemnew.target.prototype gelesen wird. Um sicherzustellen, dass (1)Base mitnew konstruiert wird, und (2)new.target auf die Unterklasse anstatt aufBase selbst zeigt, müssen wirReflect.construct() verwenden.

function BetterMap(entries) {  // Call the base class constructor, but setting `new.target` to the subclass,  // so that the instance created has the correct prototype chain.  return Reflect.construct(Map, [entries], BetterMap);}BetterMap.prototype.upsert = function (key, actions) {  if (this.has(key)) {    this.set(key, actions.update(this.get(key)));  } else {    this.set(key, actions.insert());  }};Object.setPrototypeOf(BetterMap.prototype, Map.prototype);Object.setPrototypeOf(BetterMap, Map);const map = new BetterMap([["a", 1]]);map.upsert("a", {  update: (value) => value + 1,  insert: () => 1,});console.log(map.get("a")); // 2

Wenn Sie jedoch ES6-Code schreiben, sollten Sie stattdessen Klassen undextends verwenden, da es lesbarer und weniger fehleranfällig ist.

class BetterMap extends Map {  // The constructor is omitted because it's just the default one  upsert(key, actions) {    if (this.has(key)) {      this.set(key, actions.update(this.get(key)));    } else {      this.set(key, actions.insert());    }  }}const map = new BetterMap([["a", 1]]);map.upsert("a", {  update: (value) => value + 1,  insert: () => 1,});console.log(map.get("a")); // 2

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Funktionen
• Klassen
• new
• this