Il existe de nombreuses façons de créer des objets dans JavaScript.
Constructeur d'objet / objet littéral :
En mettant de côté le modèle de conception, la méthode la plus élémentaire est d'appeler d'abord le constructeur d'objet pour créer un objet, puis d'ajouter des attributs à l'objet.
La copie de code est la suivante:
var étudiant = nouveau objet ();
Student.name = "Xiao Ming";
Student.age = 20;
Student.getName = function () {
alert (this.name);
}
Les étudiants qui connaissent l'objet javascript littéral peuvent passer à une meilleure façon d'écrire, au moins cela semble plus concis.
La copie de code est la suivante:
var étudiant = {
Nom: "Xiao Hong",
Âge: 18 ans,
getName: function () {
alert (this.name);
}
};
Inconvénients: l'un des inconvénients de la méthode ci-dessus est que lorsque vous utilisez la même interface pour créer de nombreux objets similaires, un grand nombre de code en double sera généré. Cela devrait être facile à comprendre. Les fonctions (méthodes ou classes) sont généralement utilisées pour créer des méthodes publiques. Le processus de création d'objets ci-dessus n'a aucune ombre de fonctions du tout, il n'y a donc pas de réutilisation.
Mode d'usine :
Le modèle d'usine résume le processus de création d'un objet concret. Tout comme une boîte noire, il vous suffit d'appeler la fonction (entrez l'usine) et de passer dans les paramètres correspondants (diverses matières premières), et un objet correspondant (produit produit par l'usine) sortira. Le modèle d'usine résout le problème de la création de plusieurs objets similaires.
La copie de code est la suivante:
fonction StudentFactory (nom, âge) {
var étudiant = nouveau objet ();
Student.Name = name;
Student.age = âge;
Student.sayName = function () {
alert (this.name);
}
Retour étudiant;
}
var p1 = StudentFactory ("Ming", 20);
var p2 = StudentFactory ("hong", 18);
Inconvénients: Le modèle d'usine a également ses inconvénients, et le plus grand inconvénient est la question de la reconnaissance du type d'objet. Il peut être déterminé que l'objet est de type d'objet (objet d'instance P1), mais il est impossible de déterminer de quel type il s'agit. Les élèves créés à l'aide du mode d'usine ont des propriétés et des méthodes similaires, mais les valeurs sont différentes. Une meilleure solution pour le moment consiste à créer une fonction étudiante afin que tous les objets appartiennent au type d'élève. Le mode d'usine n'est donc pas mauvais, mais le mode constructeur est meilleur.
Constructeur de type personnalisé:
Les constructeurs peuvent être utilisés pour créer des objets d'un type spécifique.
La copie de code est la suivante:
fonction Student (nom, âge) {
this.name = name;
this.age = âge;
this.sayName = function () {
alert (this.name);
}
}
var p3 = New Student ("Ming", 20);
var p4 = nouveau étudiant ("hong", 18);
alerte (instance p3 de l'étudiant);
alert (p3.sayName == p4.sayName); //FAUX
Inconvénients: l'inconvénient des constructeurs personnalisés est que chaque objet recréera sa propre méthode. En fait, ces méthodes ont la même fonction (comme SayName), mais elles ne sont pas les mêmes (P3.SayName et P4.SayName ne sont pas égales).
Mode prototype:
Définissez une fonction vide et ajoutez toutes les propriétés et méthodes au prototype afin que tous les objets partagent ces propriétés et méthodes.
La copie de code est la suivante:
fonction Student () {};
Student.prototype.name = "Ming";
Student.prototype.age = 20;
Student.prototype.friends = ['qi'];
Student.prototype.sayName = function () {
alert (this.name);
};
Inconvénients: certains attributs ne peuvent pas être partagés et les partager apportent des problèmes, tels que: des amis. La plupart des amis de chaque élève ne seront pas les mêmes.
Combinaison de constructeur et de prototype:
La copie de code est la suivante:
Student de fonction (nom, âge, amis) {
this.name = name;
this.age = âge;
this.friends = amis;
}
Student.prototype = {
Constructeur: étudiant,
SayName: function () {
alert (this.name);
}
};
Résumé: La combinaison de constructeurs et de prototypes est une méthode largement reconnue pour créer des types personnalisés. C'est également la meilleure méthode parmi les méthodes ci-dessus.
/ ************************************************************************************************************** /
En fait, il existe déjà de nombreuses méthodes pour créer des objets ci-dessus, mais il existe encore des scénarios spéciaux qui nécessitent une optimisation continue.
Mode prototype dynamique:
Il s'agit d'une optimisation de la combinaison de constructeurs et de prototypes. Pour ces attributs et méthodes communs, s'ils sont initialisés, il n'est pas nécessaire de répéter l'initialisation pour améliorer l'efficacité.
La copie de code est la suivante:
fonction Student (nom, âge) {
this.name = name;
this.age = âge;
if ((typeof this.sayName)! = "fonction") {
Student.prototype.sayName = function () {
alert (this.name);
}
}
}
var stu = new personne ("ming", 20);
// alerte (instance STU de l'étudiant);
Stu.SayName ();
var strelow = new personne ("hong", 18);
// alerte (instance Strelow de l'étudiant);
STOMEW.SAYNAME ();
Lorsque plusieurs objets étudiants sont créés, la méthode SayName n'est initialisée qu'une seule fois.
Enfin, il existe un autre moyen très utile de créer des objets, qui consiste à construire en toute sécurité les fonctions.
Modèle de constructeur stable:
Ceci et nouveau sont interdits dans ce mode, et tous les objets n'ont pas d'attributs publics. Seule la valeur de la variable est lue, mais non modifiée.
La copie de code est la suivante:
//// mode constructeur de stafe
fonction Student (nom, âge) {
var o = nouvel objet ();
o.sayName = function () {
alerte (nom);
}
retour o;
}
var stu = étudiant ("ming", 21);
Stu.SayName ();
Ce qui précède résume plusieurs méthodes JavaScript communes pour créer des objets personnalisés, qui sont très complets. Si vous en avez de meilleurs, veuillez me contacter. Cet article continue d'être mis à jour.