Triez l'encapsulation et l'héritage dans les objets JS.
1. Emballage
Il existe de nombreuses méthodes de mise en œuvre pour l'encapsulation dans JS, et voici quelques-unes couramment utilisées.
1.1 Objet de génération de motifs d'origine
Écrivez nos membres directement dans l'objet et renvoyez-les avec une fonction. Inconvénients: il est difficile de voir qu'il s'agit d'un exemple de modèle.
Code:
La copie de code est la suivante:
fonction Stu (nom, score) {
retour {
Nom: Nom,
Score: score
}
}
var Stu1 = Stu ("Zhang San", 80);
var stu2 = Stu ("li si", 90);
console.log (Stu1.Name); // Zhang San
1.2 Générer des objets de motifs construits
JS nous aide à fournir un modèle pour générer des objets à l'aide de constructeurs. Le soi-disant "constructeur" est en fait une fonction ordinaire, mais cette variable est utilisée en interne. Lorsque le nouveau mot-clé est utilisé pour générer une instance du constructeur, cette variable sera liée à l'objet d'instance.
Téléchargez directement le code:
La copie de code est la suivante:
fonction Stu (nom, score) {
this.name = name,
this.score = score
}
var stu1 = new Stu ("Zhang San", 80);
var stu2 = new Stu ("li si", 90);
console.log (Stu1.Name + "/" + Stu2.Score); // Zhang San90
console.log ((Stu1.Constructor == Stu) + "/" + (Stu2.Constructor == Stu)); // vrai vrai
console.log ((instance Stu1 de Stu) + "/" + (instance Stu2of Stu)); // vrai vrai
Il n'est pas difficile de voir que le constructeur JS génère des objets et C # avec la classe génère des objets. Les deux modèles utilisent pour définir les membres de l'objet les instancient via de nouveaux mots clés.
Générer le même objet STU à l'aide du code C #
La copie de code est la suivante:
Classe Stu
{
nom de chaîne publique;
Score double public;
}
Ok, voici l'objet de base. Nous avons donc maintenant besoin d'une méthode où tous les objets sont communs, et nous n'avons créé cette méthode qu'une seule fois. (Ne créez pas à plusieurs reprises avec l'objet nouveau) Que dois-je faire? Tout le monde sait qu'en C #, nous pouvons utiliser des membres statiques. Alors, comment le faire dans JS?
1.3 Mode prototype
Dans JS, chaque constructeur a un attribut prototype, et toutes les propriétés et méthodes de cet objet seront héritées par l'instance du constructeur. Ensuite, l'ajout de membres au prototype directement équivaut à déclarer un membre statique en C #.
Code:
La copie de code est la suivante:
fonction Stu (nom, score) {
this.name = name,
this.score = score
}
Stu.prototype.type = 'étudiant';
Stu.prototype.log = fonction (s) {
console.log (s);
}
var stu1 = new Stu ("Zhang San", 80);
var stu2 = new Stu ("li si", 90);
console.log (Stu1.Type + "/" + Stu2.Type); // Étudiants
Stu1.log ('Hello'); // Bonjour
console.log (Stu1.log == Stu2.Log); // vrai
C’est une question d’encapsulation. Voyons comment l'héritage est mis en œuvre dans JS?
2. Héritage
2.1 Liaison du constructeur
Appelez ou appliquez des méthodes directement dans la fonction enfant pour lier le constructeur de l'objet parent à l'objet enfant.
La copie de code est la suivante:
fonction Stu (nom, score) {
Grade.apply (ceci, arguments);
//Grade.Call (ces arguments);
this.name = name,
this.score = score
}
fonction de fonction () {
this.code = "Junior High School";
this.ask = function () {
Console.log ("Bonjour à tous");
}
}
var stu1 = new Stu ("Zhang San", 80);
var stu2 = new Stu ("li si", 90);
console.log (Stu1.code); // Junior High School
Stu1.ask (); // Bonjour à tous
Appliquer fait deux choses ici, mettez le premier paramètre au constructeur de grade (appelant), puis exécutez le code en grade. Il équivaut à l'exécution des membres définis en grade avec cela à nouveau dans STU.
2.2 Héritage par le prototype
Regardez d'abord le code
Code:
La copie de code est la suivante:
fonction Stu (nom, score) {
this.name = name,
this.score = score
}
fonction de fonction () {
this.code = "Junior High School";
}
Stu.prototype = new grade ();
Stu.prototype.constructor = Stu; // empêcher le trouble de la chaîne de succession et réinitialiser manuellement la déclaration
var stu1 = new Stu ("Zhang San", 80);
var stu2 = new Stu ("li si", 90);
console.log (stu.prototype.constructeur); // propre constructeur
console.log (Stu1.code); // Junior High School
Comme mentionné précédemment, le prototype est équivalent aux membres statiques en C #, nous transformons donc tous les membres de la classe parents en leurs propres membres statiques pour atteindre l'héritage.
Il y a un inconvénient à hériter par le prototype: tous les membres hérités sont statiques, alors comment hériter des membres d'objets?
2.3 Copier l'héritage
Copiez toutes les propriétés et méthodes de l'objet parent dans l'objet enfant pour réaliser l'héritage.
Code:
La copie de code est la suivante:
fonction Stu (nom, score) {
this.name = name,
this.score = score
}
fonction de fonction () {}
Grade.prototype.code = "Junior High School";
}
// Encapsulation de la fonction
fonction de fonction (c, p) {
var p = p.prototype;
var c = c.prototype;
pour (var i dans p) {
c [i] = p [i];
}
}
étendre (STU, grade);
var stu1 = new Stu ("Zhang San", 80);
var stu2 = new Stu ("li si", 90);
Stu1.code = 'lycée';
console.log (Stu1.code); // Lycée
console.log (Stu2.Code); // Junior High School
console.log (stu.prototype.constructeur);
console.log (grade.prototype.constructeur)
C'est ce que j'ai écrit sur l'organisation axée sur les objets JS. Cette chose n'est pas statique. Lorsque vous l'utilisez, apportez des modifications en fonction de vos besoins. Il y a un dicton qui va très bien, le bon est le meilleur.
Ceci n'est analysé que pour l'encapsulation et l'héritage. Nous ferons d'autres articles à l'avenir pour permettre aux amis de mieux comprendre la programmation orientée objet JavaScript. Bien sûr, tout est une compréhension personnelle. S'il y a des omissions, veuillez me contacter.