new

constructor

Eine Klasse oder Funktion, die den Typ der Objektinstanz spezifiziert. Der Ausdruck kann alles mit ausreichender Priorität sein, einschließlich eines Identifikators, eines Property-Zugriffs oder eines anderen new Ausdrucks, aber optionale Verkettung ist nicht erlaubt.

arg1, arg2, …, argN

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

Wenn eine Funktion mit dem new Schlüsselwort aufgerufen wird, wird die Funktion als Konstruktor verwendet. new führt folgende Aufgaben aus:

1. Erstellt ein leeres, einfaches JavaScript-Objekt. Um der Bequemlichkeit willen nennen wir es newInstance.

2. Verweist das [[Prototype]] von newInstance auf die prototype Eigenschaft der Konstruktorfunktion, wenn das prototype ein Object ist. Andernfalls bleibt newInstance als einfaches Objekt mit Object.prototype als [[Prototype]] bestehen.

   Hinweis: Eigenschaften/Objekte, die zur prototype Eigenschaft der Konstruktorfunktion hinzugefügt werden, sind somit für alle Instanzen zugänglich, die von der Konstruktorfunktion erstellt wurden.

3. Führt die Konstruktorfunktion mit den gegebenen Argumenten aus und bindet newInstance als this Kontext (d. h. alle Verweise auf this in der Konstruktorfunktion beziehen sich jetzt auf newInstance).

4. Wenn die Konstruktorfunktion einen nicht-primitiven Wert zurückgibt, wird dieser Rückgabewert das Ergebnis des gesamten new Ausdrucks. Andernfalls, wenn die Konstruktorfunktion nichts zurückgibt oder einen primitiven Wert zurückgibt, wird stattdessen newInstance 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 dem new Operator instanziiert werden – der Versuch, eine Klasse ohne new aufzurufen, wird einen TypeError werfen.

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

1. Definieren Sie den Objekttyp, indem Sie eine Funktion schreiben, die den Namen und die Eigenschaften des Objekts spezifiziert. Zum Beispiel könnte eine Konstruktorfunktion zur Erstellung eines Objekts Foo folgendermaßen aussehen:

   js

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

2. Erstellen Sie eine Instanz des Objekts mit new.

   js

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

Sie können einer zuvor definierten Objektinstanz jederzeit eine Eigenschaft hinzufügen. Zum Beispiel fügt die Anweisung car1.color = "black" die Eigenschaft color zu car1 hinzu und weist ihr den Wert "black" zu.

Dies beeinflusst jedoch keine anderen Objekte. Um die neue Eigenschaft allen Objekten des gleichen Typs hinzuzufügen, müssen Sie die Eigenschaft zur prototype Eigenschaft des Konstruktors hinzufügen. Dadurch wird eine Eigenschaft definiert, die von allen mit dieser Funktion erstellten Objekten geteilt wird, anstatt von nur einer Instanz des Objekttyps. Der folgende Code fügt allen Objekten des Typs Car eine color Eigenschaft mit dem Wert "original color" hinzu und überschreibt diesen Wert dann mit dem String "black" nur im Instanzobjekt car1. Weitere Informationen finden Sie unter Prototype.

function Car() {}
const car1 = new Car();
const car2 = new Car();

console.log(car1.color); // undefined

Car.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 wissen, ob sie mit new aufgerufen wird, indem sie new.target prüft. new.target ist nur dann undefined, wenn die Funktion ohne new aufgerufen wird. Zum Beispiel können Sie eine Funktion haben, die sich anders verhält, wenn sie aufgerufen wird, im Vergleich zu wenn sie 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, das Klassen eingeführt hat, sind die meisten JavaScript-Built-ins sowohl aufrufbar als auch konstruierbar, obwohl viele von ihnen unterschiedliche Verhaltensweisen zeigen. Um einige zu nennen:

• Array(), Error(), und Function() verhalten sich gleich, wenn sie als Funktion oder als Konstruktor aufgerufen werden.
• Boolean(), Number() und String() zwingen ihr Argument beim Aufruf in den jeweiligen primitiven Typ, und geben Wrapper-Objekte zurück, wenn sie konstruiert werden.
• Date() gibt beim Aufruf einen String zurück, der das aktuelle Datum darstellt, was new Date().toString() entspricht.

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

• Symbol() und BigInt() können nur ohne new aufgerufen werden. Der Versuch, sie zu konstruieren, wird einen TypeError werfen.
• Proxy und Map können nur mit new konstruiert werden. Der Versuch, sie aufzurufen, wird einen TypeError werfen.

Angenommen, Sie möchten einen Objekttyp für Autos erstellen. Sie möchten, dass dieser Objekttyp Car genannt wird, und Sie möchten, dass er Eigenschaften für Marke, Modell und Jahr hat. 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 namens myCar wie folgt erstellen:

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

Diese Anweisung erstellt myCar und weist ihm die angegebenen Werte für seine Eigenschaften zu. Dann ist der Wert von myCar.make der String "Eagle", myCar.year ist die ganze Zahl 1993, und so weiter.

Sie können eine beliebige Anzahl von car Objekten durch Aufrufe von new erstellen. Zum Beispiel:

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

Angenommen, Sie definieren ein Objekt namens Person wie folgt:

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

Und dann instanziieren Sie zwei neue Person 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 von Car um eine owner Eigenschaft erweitern, die ein Person Objekt erfordert, 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 das folgende:

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

Anstatt einen Literalstring oder eine ganze Zahl beim Erstellen der neuen Objekte zu übergeben, übergeben die oben stehenden Anweisungen die Objekte rand und ken als Parameter für die Eigentümer. Um den Namen des Eigentümers von car2 herauszufinden, können Sie auf die folgende Eigenschaft zugreifen:

car2.owner.name;

• Function
• Reflect.construct()
• Object