Il existe de nombreuses façons de définir des cours dans JS:
1. Méthode d'usine
La copie de code est la suivante:
fonction de fonction () {
var ocar = nouvel objet;
ocar.color = "bleu";
ocar.doors = 4;
ocar.showcolor = function () {
document.write (this.color)
};
retour OCAR;
}
var car1 = car ();
var car2 = car ();
Lorsque cette fonction est appelée, un nouvel objet est créé et toutes les propriétés et méthodes sont attribuées. Utilisez cette fonction pour créer 2 objets avec exactement les mêmes propriétés. Bien sûr, ma sœur peut modifier cette méthode en y faisant passer des paramètres.
La copie de code est la suivante:
voiture de fonction (couleur, porte) {
var ocar = nouvel objet;
ocar.color = couleur;
ocar.doors = porte;
ocar.showcolor = function () {
document.write (this.color)
};
retour OCAR;
}
var car1 = car ("rouge", 4);
var car2 = car ("bleu", 4);
car1.showColor () // Sortie: "rouge"
car2.showColor () // Sortie: "bleu"
Vous pouvez maintenant obtenir des objets avec différentes valeurs en passant différents paramètres à la fonction.
Dans l'exemple précédent, chaque fois que la voiture de fonction () est appelée, la présentation () est créée, ce qui signifie que chaque objet a sa propre méthode showcolor ().
Mais en fait, chaque objet partage la même fonction.
Bien qu'une méthode puisse être définie en dehors de la fonction, alors en pointant les propriétés de la fonction à la méthode.
La copie de code est la suivante:
fonction showcolor () {
alerte (this.color);
}
fonction de fonction () {
var ocar = nouveau objet ();
ocar.color = couleur;
ocar.doors = porte;
ocar.showColor = Showcolor;
retour OCAR;
}
Mais cela ne ressemble pas à une méthode de fonction.
2. Méthode du constructeur
La méthode du constructeur est aussi simple que la méthode d'usine, comme indiqué ci-dessous:
La copie de code est la suivante:
voiture de fonction (couleur, porte)
Vous pouvez voir que la méthode du constructeur ne crée pas d'objets à l'intérieur de la fonction et le mot-clé qui est utilisé. Parce qu'un objet a été créé lors de l'appel du constructeur, et cela ne peut être utilisé que pour accéder aux propriétés d'objet dans la fonction.
Utilisez maintenant nouveau pour créer des objets, il ressemble à ça! Mais c'est la même chose que l'usine. Chaque appel crée sa propre méthode pour l'objet.
3. Méthode prototype
Cette méthode tire parti de l'attribut prototype de l'objet. Tout d'abord, créez le nom de classe avec une fonction vide, puis tous les attributs et méthodes sont affectés à l'attribut prototype.
La copie de code est la suivante:
Fonction Car ()
Dans ce code, une fonction vide est d'abord définie, puis les propriétés de l'objet sont définies via l'attribut prototype. Lorsque cette fonction est appelée, toutes les propriétés du prototype seront attribuées à l'objet à créer immédiatement. Tous les objets de cette fonction Store Pointers pour présenter (), qui semble syntaxiquement appartenir au même objet.
Cependant, cette fonction n'a pas de paramètres et l'attribut ne peut pas être initialisé en passant par des paramètres. La valeur par défaut de l'attribut doit être modifiée après la création de l'objet.
Un problème très grave avec la méthode du prototype est que lorsque l'attribut pointe vers un objet, comme un tableau.
La copie de code est la suivante:
fonction de fonction () {
}
Car.prototype.color = "red";
Car.prototype.doors = 4;
Car.prototype.arr = nouveau tableau ("a", "b");
Car.prototype.showcolor = function () {
alerte (this.color);
}
var car1 = new car ();
var car2 = new car ();
car1.arr.push ("cc");
alerte (car1.arr); // Sortie: AA, BB, CC
alerte (car2.arr); // Sortie: AA, BB, CC
Ici, en raison de la valeur de référence du tableau, les deux objets de voiture pointent vers le même tableau, donc lorsque la valeur est ajoutée dans Car1, vous pouvez également la voir dans Car2.
Union est une méthode qui peut créer des objets comme d'autres langages de programmation utilisant le constructeur / prototype. Il s'agit d'une méthode qui utilise des constructeurs pour définir les propriétés non fonctionnelles des objets et utilise des prototypes pour définir des objets.
La copie de code est la suivante:
voiture de fonction (couleur, porte) {
this.color = couleur;
this.doors = porte;
this.arr = new Array ("aa", "bb");
}
Car.prototype.showcolor () {
alerte (this.color);
}
var car1 = new Car ("Red", 4);
var car2 = new car ("bleu", 4);
car1.arr.push ("cc");
alerte (car1.arr); // Sortie: AA, BB, CC
alerte (car2.arr); // Sortie: AA, BB
4. Méthode de prototype dynamique
La méthode du prototype dynamique est similaire à la méthode de constructeur / prototype mixte. La seule différence est la position donnée à la méthode de l'objet.
La copie de code est la suivante:
voiture de fonction (couleur, porte) {
this.color = couleur;
this.doors = porte;
this.arr = new Array ("aa", "bb");
if (typeof car._Initialized == "Undefined") {
Car.prototype.showcolor = function () {
alerte (this.color);
};
Car._Initialized = true;
}
}
La méthode du prototype dynamique consiste à utiliser un drapeau pour déterminer si le prototype a été attribué une méthode. Cela garantit que la méthode n'est créée qu'une seule fois
6. Méthode d'usine mixte
Son professeur de but crée un faux constructeur qui ne renvoie que de nouvelles instances d'un autre objet.
La copie de code est la suivante:
fonction de fonction () {
var ocar = nouveau objet ();
Ocar.Color = "Red";
ocar.doors = 4;
ocar.showcolor = function () {
alerte (this.color)
};
retour OCAR;
}
Contrairement à la méthode d'usine, cette méthode utilise le nouvel opérateur.
PS (compréhension personnelle):
1) Les membres (méthodes ou attributs) définis par la classe via le prototype sont partagés par chaque objet de classe. Ils ne sont généralement pas utilisés pour définir les attributs des membres. Si un objet modifie la valeur d'attribut, tous les objets sont modifiés;
2) La classe a un attribut prototype, mais l'objet de classe ne le fait pas;
3) Chaque fois qu'un nouvel objet de classe ou une classe est appelé directement (le formulaire de méthode d'usine suivant), l'instruction qui définit la classe (fonction) sera exécutée une fois (le modèle Singleton peut éviter cette situation);
4) La classe est le type de fonction, l'objet de classe est type d'objet et seul le type de fonction est un attribut prototype;
5) La méthode définie par le prototype ne peut pas accéder aux variables privées de la classe (variables locales définies par la classe), mais les propriétés des membres et les méthodes membre de la classe (variables et méthodes définies par ceci) peuvent être accessibles à travers cela;
6) Comment définir une classe:
un. Méthode d'usine (objet)
B. Méthode d'inhéritage (prototype)
C. Méthode de la construction (ceci)
d. Méthode mixte
7) [Question] Pourquoi les attributs définis par le prototype peuvent-ils être modifiés via n'importe quel objet? Les attributs définis dans la méthode du constructeur n'appartiennent qu'à l'objet et n'affecteront pas les valeurs d'attribut des autres objets?
Ce qui précède sont toutes les méthodes de création d'objets. La méthode la plus utilisée est la méthode de constructeur / prototype hybride, et la méthode de prototype dynamique est également très populaire. Fonctionnellement équivalent à la méthode du constructeur / prototype.