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) {
this.color = couleur;
this.doors = porte;
this.showColor = function () {
alerte (this.color)
};
}
var car1 = new Car ("Red", 4);
var car2 = new car ("bleu", 4);
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.
Maintenant, en utilisant 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 de fonction () {
}
Car.prototype.color = "red";
Car.prototype.doors = 4;
Car.prototype.showcolor = function () {
alerte (this.color);
}
var car1 = new car ();
var car2 = new 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
5. 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.
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.
Ce qui précède est tout sur cet article, j'espère que vous l'aimez.