1. Was ist ein Konstruktor?
Konstruktoren sind in einigen objektorientierten Sprachen wie Java, C ++ und PHP sehr häufig. In JavaScript ist der Konstruktor zunächst eine normale Funktion, die mit dem neuen Bediener aufgerufen werden kann und ein Objekt des speziellen Typs generiert.
Die Codekopie lautet wie folgt:
// "Benjamin" ist ein Konstruktor
var Benjamin = neuer Benjamin ("Zuojj", "männlich");
Im obigen Beispiel ist Benjamin ein Benjamin -Objekt. Wie instanziiert es also?
Die Codekopie lautet wie folgt:
Funktion Benjamin (Benutzername, Sex) {
this.username = userername;
this.sex = sex;
}
var Benjamin = neuer Benjamin ("Zuojj", "männlich");
// Ausgänge: Benjamin {Sex: "männlich", Benutzername: "Zuojj"}
console.log (Benjamin);
Wie wir sehen können, empfängt der Konstruktor "Benjamin" einfach übergebene Parameter und weist sie diesem Objekt zu. Dies liegt daran, dass der Konstruktor, wenn der Konstruktor vom neuen Bediener aufgerufen wird, dem von der neuen Operation zurückgegebenen Objekt des Konstruktors zugewiesen wird.
Dies bedeutet, dass der obige Code entspricht:
Die Codekopie lautet wie folgt:
Benjamin = {
"Benutzername": "Zuojj",
"Sex": "Männlich"
}
2. Warum Konstruktoren verwenden
Es gibt mehrere Gründe, warum Konstruktoren verwendet werden:
1. Die Verwendung von Konstruktoren bedeutet, dass alle diese Objekte mit derselben Grundstruktur erstellt werden können.
2. Die Verwendung eines Konstruktors bedeutet, dass das "Benjamin" -Objekt explizit als Instanz der "Benjamin" -Funktion markiert wird
Die Codekopie lautet wie folgt:
Funktion Benjamin (Benutzername, Sex) {
this.username = userername;
this.sex = sex;
}
var Benjamin = neuer Benjamin ("Zuojj", "männlich");
var ben = {
"Benutzername": "Zuojj",
"Sex": "Männlich"
}
// Ausgänge: True
console.log (Benjamin Instanz von Benjamin);
// Ausgänge: Falsch
console.log (Ben Instanz von Benjamin);
3. Die Verwendung von Konstruktoren bedeutet, dass wir öffentliche Methoden im Prototyp zum Teilen mehrerer Instanzen definieren können
Die Codekopie lautet wie folgt:
Funktion Benjamin (Benutzername, Sex) {
this.username = userername;
this.sex = sex;
}
Benjamin.Prototype.getName = function () {
kehre diesen.usernamen zurück;
}
var Benjamin = neuer Benjamin ("Zuojj", "männlich");
var Ben = neuer Benjamin ("Zitrone", "weiblich");
// Ausgänge: Zuojj
console.log (Benjamin.getName ());
// Ausgänge: Zitrone
console.log (ben.getName ());
3.. Dinge zu beachten
1. Neue Schlüsselwörter
Wenn Sie den Konstruktor instanziieren, müssen Sie nicht vergessen, das neue Schlüsselwort zu verwenden. Ob das neue Keyword verwendet wird, hat einen großen Einfluss auf dieses Objekt. Ohne das neue Keyword verweist dieses Objekt auf das globale Objekt (Fenster im Browser und global im Knoten). Bei der Definition eines Konstruktors wird daher empfohlen, dass der erste Buchstabe des Funktionsnamens aktiviert wird.
2. Wenn die aufgerufene Funktion keinen expliziten Renditexpression hat, wird dieses Objekt implizit zurückgegeben, was das neu erstellte Objekt ist. Andernfalls ist das Ergebnis betroffen, jedoch nur, wenn das zurückgegebene Objekt ist
Die Codekopie lautet wie folgt:
Funktions bar () {
Rückkehr 2;
}
var bar = new bar ();
// das neu erstellte Objekt zurückgeben
// Ausgänge: bar {}
console.log (bar);
Funktionstest () {
this.Value = 2;
zurückkehren {
Foo: 1
};
}
var test = neuer Test ();
// zurückgegebenes Objekt
// Ausgänge: Objekt {Foo: 1}
console.log (test);
Was wir beachten müssen, ist:
A) New Bar () gibt das neu erstellte Objekt zurück, nicht den wörtlichen Wert der Zahl 2. Daher neuer bar (). Konstruktor === bar, aber wenn das zurückgegebene Zahlenobjekt, ist das Ergebnis unterschiedlich;
b) Der hier erhaltene neue Test () ist ein von der Funktion zurückgegebener Objekt, kein neu erstelltes Objekt über das neue Schlüsselwort, wie unten gezeigt:
Die Codekopie lautet wie folgt:
Funktions bar () {
Rückkehr 2;
}
var bar = new bar ();
Funktion Barn () {
Neue Nummer (2) zurückgeben;
}
var baln = new Barn ();
// Ausgänge: True
console.log (bar.constructor === bar);
// Ausgänge: Nummer {}
console.log (scheune);
// Ouputs: Falsch
console.log (Barn.Constructor === Barn);
// Ausgänge: True
console.log (Barn.Constructor === Nummer);
/ * ---------------------------------- *///
Funktionstest () {
this.Value = 2;
zurückkehren {
Foo: 1
};
}
var test = neuer Test ();
// Ausgänge: undefiniert
console.log (test.Value);
// Ouputs: 1
console.log (test.foo);
Das obige ist eine Zusammenfassung des Konstruktors. Ich hoffe, es wird für Anfänger hilfreich sein. Wenn es im Artikel unangemessene Punkte gibt, hoffe ich, sie zu kritisieren und zu korrigieren.