Dernew Operator ermöglicht es Entwicklern, eine Instanz eines benutzerdefinierten Objekttyps oder eines der integrierten Objekttypen zu erstellen, die eine Konstruktorfunktion besitzen.

Probieren Sie es aus

function Car(make, model, year) {  this.make = make;  this.model = model;  this.year = year;}const car1 = new Car("Eagle", "Talon TSi", 1993);console.log(car1.make);// Expected output: "Eagle"

Syntax

new constructornew constructor()new constructor(arg1)new constructor(arg1, arg2)new constructor(arg1, arg2, /* …, */ argN)

Parameter

constructor

Eine Klasse oder Funktion, die den Typ der Objektinstanz angibt. Der Ausdruck kann alles mit ausreichenderPriorität sein, einschließlich eines Identifikators, einesEigenschaftszugriffs oder eines weiterennew Ausdrucks, aberOptionale Verkettung ist nicht erlaubt.

arg1,arg2, …,argN

Eine Liste von Werten, mit denen derconstructor aufgerufen wird.new Foo ist äquivalent zunew Foo(), d.h. wenn keine Argumentenliste angegeben wird, wirdFoo ohne Argumente aufgerufen.

Beschreibung

Wenn eine Funktion mit demnew Schlüsselwort aufgerufen wird, wird die Funktion als Konstruktor verwendet.new führt die folgenden Schritte aus:

1. Erstellt ein leeres, einfaches JavaScript-Objekt. Der Einfachheit halber nennen wir esnewInstance.

2. SetztnewInstance's [[Prototype]] auf dieprototype-Eigenschaft der Konstruktorfunktion, falls dasprototype einObject ist. Andernfalls bleibtnewInstance ein einfaches Objekt mitObject.prototype als seinem [[Prototype]].

   Hinweis:Eigenschaften/Objekte, die derprototype-Eigenschaft der Konstruktorfunktion hinzugefügt werden, sind daher für alle Instanzen zugänglich, die aus der Konstruktorfunktion erstellt wurden.

3. Führt die Konstruktorfunktion mit den gegebenen Argumenten aus und bindetnewInstance alsthis Kontext (d.h. alle Verweise aufthis in der Konstruktorfunktion beziehen sich jetzt aufnewInstance).

4. Wenn die Konstruktorfunktion einennicht-primitiven Wert zurückgibt, wird dieser Rückgabewert das Ergebnis des gesamtennew Ausdrucks. Andernfalls, wenn die Konstruktorfunktion nichts zurückgibt oder einen primitiven Wert zurückgibt, wirdnewInstance stattdessen zurückgegeben. (Normalerweise geben Konstruktoren keinen Wert zurück, aber sie können dies tun, um den normalen Objekt-Erstellungsprozess zu überschreiben.)

Klassen können nur mit demnew Operator instanziiert werden — der Versuch, eine Klasse ohnenew aufzurufen, führt zu einemTypeError.

Das Erstellen eines Objekts mit einer benutzerdefinierten Konstruktorfunktion erfordert zwei Schritte:

1. Den Objekttyp definieren, indem eine Funktion geschrieben wird, die seinen Namen und seine Eigenschaften angibt.Zum Beispiel könnte eine Konstruktorfunktion, um ein ObjektFoo zu erstellen, folgendermaßen aussehen:

   js

   function Foo(bar1, bar2) {  this.bar1 = bar1;  this.bar2 = bar2;}

2. Eine Instanz des Objekts mitnew erstellen.

   js

   const myFoo = new Foo("Bar 1", 2021);

Sie können einem zuvor definierten Objekt immer eine Eigenschaft hinzufügen. Zum Beispiel fügt die Anweisungcar1.color = "black" eine Eigenschaftcolor zucar1 hinzu und weist ihr den Wert"black" zu.

Dies beeinflusst jedoch keine anderen Objekte. Um die neue Eigenschaft zu allen Objekten des gleichen Typs hinzuzufügen, müssen Sie die Eigenschaft zurprototype-Eigenschaft des Konstruktors hinzufügen. Dies definiert eine Eigenschaft, die von allen mit dieser Funktion erstellten Objekten geteilt wird, anstatt nur von einer Instanz des Objekttyps. Der folgende Code fügt einecolor Eigenschaft mit dem Wert"original color" zu allen Objekten des TypsCar hinzu und überschreibt dann diesen Wert nur im Instanzobjektcar1 mit dem String"black". Für weitere Informationen sieheprototype.

function Car() {}const car1 = new Car();const car2 = new Car();console.log(car1.color); // undefinedCar.prototype.color = "original color";console.log(car1.color); // 'original color'car1.color = "black";console.log(car1.color); // 'black'console.log(Object.getPrototypeOf(car1).color); // 'original color'console.log(Object.getPrototypeOf(car2).color); // 'original color'console.log(car1.color); // 'black'console.log(car2.color); // 'original color'

Eine Funktion kann erkennen, ob sie mitnew aufgerufen wurde, indem sienew.target überprüft.new.target ist nurundefined, wenn die Funktion ohnenew aufgerufen wird. Zum Beispiel können Sie eine Funktion haben, die sich unterschiedlich verhält, je nachdem, ob sie aufgerufen oder konstruiert wird:

function Car(color) {  if (!new.target) {    // Called as function.    return `${color} car`;  }  // Called with new.  this.color = color;}const a = Car("red"); // a is "red car"const b = new Car("red"); // b is `Car { color: "red" }`

Vor ES6, dasKlassen eingeführt hat, sind die meisten JavaScript-Built-ins sowohl aufrufbar als auch konstruierbar, obwohl viele von ihnen unterschiedliche Verhaltensweisen zeigen. Einige Beispiele:

• Array(),Error(), undFunction() verhalten sich gleich, wenn sie als Funktion oder als Konstruktor aufgerufen werden.
• Boolean(),Number(), undString() zwingen ihr Argument in den jeweiligen primitiven Typ, wenn sie aufgerufen werden, und geben Wrapper-Objekte zurück, wenn sie konstruiert werden.
• Date() gibt einen String zurück, der das aktuelle Datum darstellt, wenn er aufgerufen wird, äquivalent zunew Date().toString().

Nach ES6 ist die Sprache strenger darüber, welche Konstruktoren und welche Funktionen sind. Zum Beispiel:

• Symbol() undBigInt() können nur ohnenew aufgerufen werden. Der Versuch, sie zu konstruieren, führt zu einemTypeError.
• Proxy undMap können nur mitnew konstruiert werden. Der Versuch, sie aufzurufen, führt zu einemTypeError.

Beispiele

Objekttyp und Objektinstanz

Angenommen, Sie möchten einen Objekttyp für Autos erstellen. Sie möchten, dass dieser ObjekttypCar genannt wird, und er soll Eigenschaften für Marke, Modell und Jahr haben.Um dies zu tun, würden Sie die folgende Funktion schreiben:

function Car(make, model, year) {  this.make = make;  this.model = model;  this.year = year;}

Nun können Sie ein Objekt namensmyCar wie folgt erstellen:

const myCar = new Car("Eagle", "Talon TSi", 1993);

Diese Anweisung erstelltmyCar und weist ihm die angegebenen Werte für seineEigenschaften zu. Dann ist der Wert vonmyCar.make der String "Eagle",myCar.year ist der Integer 1993 und so weiter.

Sie können beliebig vielecar Objekte durch Aufrufe vonnew erstellen. ZumBeispiel:

const kensCar = new Car("Nissan", "300ZX", 1992);

Objekteigenschaft, die selbst ein weiteres Objekt ist

Angenommen, Sie definieren ein Objekt namensPerson wie folgt:

function Person(name, age, sex) {  this.name = name;  this.age = age;  this.sex = sex;}

Und instanziieren dann zwei neuePerson Objekte wie folgt:

const rand = new Person("Rand McNally", 33, "M");const ken = new Person("Ken Jones", 39, "M");

Dann können Sie die Definition vonCar um eineowner Eigenschaft erweitern, die einPerson Objekt übernimmt, wie folgt:

function Car(make, model, year, owner) {  this.make = make;  this.model = model;  this.year = year;  this.owner = owner;}

Um die neuen Objekte zu instanziieren, verwenden Sie dann Folgendes:

const car1 = new Car("Eagle", "Talon TSi", 1993, rand);const car2 = new Car("Nissan", "300ZX", 1992, ken);

Anstelle eines literalen Strings oder Integer-Werts bei der Erstellung der neuen Objekte übergeben dieobigen Anweisungen die Objekterand undken alsParameter für die Eigentümer. Um den Namen des Eigentümers voncar2 herauszufinden, können Sie auf die folgende Eigenschaft zugreifen:

car2.owner.name;

Verwendung vonnew mit Klassen

class Person {  constructor(name) {    this.name = name;  }  greet() {    console.log(`Hello, my name is ${this.name}`);  }}const p = new Person("Caroline");p.greet(); // Hello, my name is Caroline

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Function
• Reflect.construct()
• Object