Detaillierte Erläuterung der fünf Möglichkeiten, Klassen in JS zu definieren

Wir wissen, dass JavaScript mittlerweile eine sehr wichtige Rolle in unserer Entwicklung spielt. In der Frontend-Entwicklung ist es oft notwendig, JS-Klassen zu definieren. In JavaScript gibt es also mehrere Möglichkeiten, eine Klasse zu definieren. In diesem Artikel werden die fünf Möglichkeiten zum Definieren von Klassen in JS wie folgt erläutert.

1. Factory-Methode

function Car(){
var ocar = new Object;
ocar.color = “blue”;
ocar.doors = 4;
ocar.showColor = function(){
document.write(this.color)
};
return ocar;
}
var car1 = Car();
var car2 = Car();

Wenn diese Funktion aufgerufen wird, wird ein neues Objekt erstellt und mit allen Funktionen versehen Attribute und Methode. Verwenden Sie diese Funktion, um zwei Objekte mit genau den gleichen Eigenschaften zu erstellen.

Natürlich kann dies durch die Übergabe von Parametern geändert werden.

function Car(color,door){
var ocar = new Object;
ocar.color = color;
ocar.doors = door;
ocar.showColor = function(){
document.write(this.color)
};
return ocar;
}
var car1 = Car(“red”,4);
var car2 = Car(“blue”,4);
car1.showColor() //output:”red”
car2.showColor() //output:”blue”

Sie können jetzt Objekte mit unterschiedlichen Werten erhalten, indem Sie unterschiedliche Parameter an die Funktion übergeben.

Im vorherigen Beispiel wird showcolor() jedes Mal erstellt, wenn die Funktion Car() aufgerufen wird, was bedeutet, dass jedes Objekt seine eigene showcolor()-Methode hat.

Aber tatsächlich hat jeder Objekt-Bucket die gleiche Funktion. Es ist zwar möglich, eine Methode außerhalb einer Funktion zu definieren und dann die Eigenschaften der Funktion auf diese Methode zu verweisen.

function showColor(){
  
alert(this.color);
}
function Car(){
var ocar = new Object();
ocar.color = color;
ocar.doors = door;
ocar.showColor = showColor;
return ocar;
}

Aber das sieht nicht nach einer Funktionsmethode aus.

2. Konstruktormethode

Die Konstruktormethode ist genauso einfach wie die Factory-Methode, wie unten gezeigt:

   
function Car(color,door){
this.color = color;
this.doors = door;
this.showColor = function(){
alert(this.color)
};
}
var car1 = new Car(“red”,4);
var car2 = new Car(“blue”,4);

Sie können sehen, dass die Konstruktormethode kein Objekt innerhalb der Funktion erstellt, sondern das Schlüsselwort this verwendet. Denn das Objekt wurde beim Aufruf des Konstruktors erstellt und nur dieses kann für den Zugriff auf Objekteigenschaften innerhalb der Funktion verwendet werden.

Jetzt verwenden Sie „Neu“, um Objekte zu erstellen, es sieht so aus! Aber es ist dasselbe wie der Fabrikansatz. Jeder Aufruf erstellt eine eigene Methode für das Objekt.

3. Prototype-Methode

Diese Methode verwendet das Prototypattribut des Objekts. Zuerst wird der Klassenname mit einer leeren Funktion erstellt, dann wird allen Eigenschaften und Methoden das Prototyp-Attribut zugewiesen.

function Car(){
}
Car.prototype.color = “red”;
Car.prototype.doors = 4;
Car.prototype.showColor = function(){
alert(this.color);
}
var car1 = new Car();
var car2 = new Car();

In diesem Code wird zunächst eine leere Funktion definiert und dann werden die Eigenschaften des Objekts über das Prototypattribut definiert. Beim Aufruf dieser Funktion werden alle Eigenschaften des Prototyps sofort dem zu erstellenden Objekt zugewiesen. Alle Objekte dieser Funktion speichern Zeiger auf showColor() und scheinen syntaktisch alle zum selben Objekt zu gehören.

Aber diese Funktion hat keine Parameter. Sie können Eigenschaften nicht durch Übergabe von Parametern initialisieren. Sie müssen den Standardwert der Eigenschaft ändern, nachdem das Objekt erstellt wurde.

Ein ernstes Problem bei der Prototypenmethode besteht darin, dass das Attribut auf ein Objekt verweist, beispielsweise auf ein Array.

   
function Car(){
}
Car.prototype.color = “red”;
Car.prototype.doors = 4;
Car.prototype.arr = new Array(“a”,”b”);
Car.prototype.showColor = function(){
alert(this.color);
}
var car1 = new Car();
var car2 = new Car();
car1.arr.push(“cc”);
alert(car1.arr); //output:aa,bb,cc
alert(car2.arr); //output:aa,bb,cc

Aufgrund des Referenzwerts des Arrays verweisen die beiden Objekte von Car auf dasselbe Array. Wenn der Wert also zu car1 hinzugefügt wird, ist er auch in car2 sichtbar.

Union ist eine Methode, die wie andere Programmiersprachen die Konstruktor-/Prototypmethode zum Erstellen von Objekten verwendet. Sie verwendet den Konstruktor zum Definieren der nichtfunktionalen Eigenschaften des Objekts und die Prototypmethode zum Definieren des Objekts.

function Car(color,door){
this.color = color;
this.doors = door;
this.arr = new Array(“aa”,”bb”);
}
Car.prototype.showColor(){
alert(this.color);
}
var car1 = new Car(“red”,4);
var car2 = new Car(“blue”,4);
car1.arr.push(“cc”);
alert(car1.arr); //output:aa,bb,cc
alert(car2.arr); //output:aa,bb

4. Dynamische Prototyp-Methode

Das Prinzip der dynamischen Prototyp-Methode ähnelt der gemischten Konstruktor/Prototyp-Methode. Der einzige Unterschied besteht darin, wo die Objektmethoden zugewiesen werden.

   
function Car(color,door){
this.color = color;
this.doors = door;
this.arr = new Array(“aa”,”bb”);
if(typeof Car._initialized == “undefined”){
Car.prototype.showColor = function(){
alert(this.color);
};
Car._initialized = true;
}
}

Die dynamische Prototypmethode verwendet ein Flag, um zu bestimmen, ob dem Prototyp eine Methode zugewiesen wurde. Dadurch wird sichergestellt, dass die Methode nur einmal erstellt wird

5. Gemischte Factory-Methode

Ihr Zweck besteht darin, einen gefälschten Konstruktor zu erstellen und nur eine neue Instanz eines anderen Objekts zurückzugeben.

function Car(){
var ocar = new Object();
ocar.color = “red”;
ocar.doors = 4;
ocar.showColor = function(){
alert(this.color)
};
return ocar;
}

Der Unterschied zur Factory-Methode besteht darin, dass diese Methode den neuen Operator verwendet.

Die oben genannten sind alle Methoden zum Erstellen von Objekten. Die derzeit am weitesten verbreitete Methode ist die gemischte Konstruktor-/Prototyp-Methode. Darüber hinaus erfreut sich auch die dynamische Prototyp-Methode großer Beliebtheit. Funktional äquivalent zum Konstruktor/Prototyp-Ansatz.

Der obige Inhalt ist eine detaillierte Erklärung der fünf Möglichkeiten, Klassen in JS zu definieren. Ich hoffe, dass er allen helfen kann.

Verwandte Empfehlungen:

So definieren Sie Klassen und Operationsbeispiele in PHP

JavaScript verwendet Funktionen, um eine detaillierte Verwendung definierter Klasseninstanzen zu implementieren

Benutzerdefinierter Javascript-Typ, Attribut, Beispielcode-Zusammenfassung für die Methode

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der fünf Möglichkeiten, Klassen in JS zu definieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!