Un. Deux prototypes
Beaucoup de gens savent que JavaScript est un héritage prototype. Chaque constructeur a un élément de prototype, à travers lequel l'héritage JavaScript peut être magnifique.
En fait, cet attribut à lui seul ne peut pas compléter l'héritage de JavaScript.
Je ne dirai pas grand-chose sur le prototype que nous utilisons dans le code. Vous pouvez vérifier les informations.
Un autre membre du prototype invisible.
Chaque instance a un attribut prototype pointant vers le prototype. Cet attribut ne peut pas être accessible et bien sûr ne peut pas être modifié, car c'est la base pour maintenir l'héritage JavaScript.
La copie de code est la suivante:
// déclaration de constructeur
fonction guoyansi () {}
fonction guoyansiex () {}
// Héritage prototype
Guoyansiex.prototype = new guoyansi ();
// Créer un objet
var g1 = new Guoyansiex ();
var g2 = new Guoyansiex ();
Les objets du code ci-dessus peuvent être expliqués par la figure suivante
2. Maintenance du prototype
Une instance générée par un constructeur dont l'attribut constructeur pointe toujours au constructeur. Nous penserons que la déclaration est correcte pour le moment.
La copie de code est la suivante:
fonction guoyansi () {}
var obj1 = new guoyansi ();
console.log (obj1.constructor === Guoyansi); // Vrai
En fait, le constructeur lui-même n'a pas l'attribut de constructeur, alors d'où vient cet attribut?
La réponse est: du prototype.
Par conséquent, les conclusions suivantes sont tirées
La copie de code est la suivante: obj1.constructor === guoyansi.prototype.constructor === Guoyansi
Étant donné que nous pouvons trouver le constructeur par le constructeur, nous pouvons encore améliorer le diagramme ci-dessus.
La copie de code est la suivante:
fonction guoyansiex () {}
Guoyansiex.prototype = new guoyansi ();
console.log (guoyansiex.constructor === guoyansiex) // false
Selon l'image ci-dessus, le résultat ci-dessus devrait être vrai, mais pourquoi est faux?
Faites maintenant une analyse.
Le prototype de Guoyansiex a été réécrit par l'instance de Guoyansi, donc le constructeur du prototype de Guoyansiex est naturellement également une instance de Guoyansi.
Le constructeur de l'instance de Guoyansi vient de guoyansi.prototype. Cependant, Guoyansi.prototype n'a pas été réécrit.
Ainsi, le constructeur de Guoyansi.prototype pointe vers Guoyansi (constructeur);
Sur la base de l'analyse ci-dessus, nous tirons les conclusions suivantes
La copie de code est la suivante: Guoyansiex.Constructor === Guoyansi.Constructor === Guoyansi;
Si les exigences de la directive du constructeur sont très précises pendant le processus de développement, le traitement suivant peut être effectué.
La copie de code est la suivante:
/ ** Méthode 1: ** /
fonction guoyansi () {}
fonction guoyansiex () {}
Guoyansiex.prototype = new guoyansi ();
Guoyansiex.prototype.constructor = guoyansiex; // réinitialiser le pointeur du constructeur.
La copie de code est la suivante:
/ **
Méthode 2
** /
fonction guoyansi () {}
fonction guoyansiex () {
this.constructor = arguments.callee;
}
Guoyansiex.prototype = new guoyansi ();
La copie de code est la suivante:
/ **
Méthode 3
** /
fonction guoyansi () {}
fonction guoyansiex () {
this.constructor = guoyansiex;
}
Guoyansiex.prototype = new guoyansi ();
3. À quoi sert un prototype invisible?
Nous pouvons exploiter la chaîne prototype visible pour compléter notre héritage, nous ne pouvons donc pas voir et utiliser cette chaîne de prototypes invisible. À quoi sert-il?
Il existe une caractéristique dans l'héritage orienté objet: la similitude. Les sous-classes ont des similitudes avec les classes des parents. Par conséquent, dans les sous-classes, vous ne pouvez pas utiliser Delete pour supprimer les membres hérités des classes parentales. C'est-à-dire que les sous-classes doivent avoir les caractéristiques des classes parentales.
Pour maintenir cette fonctionnalité, JavaScript génère une propriété de prototype invisible à l'intérieur de l'objet et ne permet pas à l'utilisateur d'y accéder. De cette façon, l'utilisateur peut modifier le constructeur à quelque fin que ce soit,
Il ne détruira pas les caractéristiques de la classe d'enfants ayant la classe parentale.
En bref: les prototypes internes sont requis par le mécanisme d'hérédité du prototype de JavaScript, tandis que les prototypes externes sont requis par les utilisateurs pour mettre en œuvre l'héritage.
4. __proto__ dans le moteur Firefox Spidermonkey
Toujours ce code.
La copie de code est la suivante:
fonction guoyansi () {}
Guoyansi.prototype.age = 24;
fonction guoyansiex () {}
var obj1 = new guoyansi ();
Guoyansiex.prototype = obj1;
Guoyansiex.prototype.constructor = guoyansiex; // réinitialiser le pointeur du constructeur.
var obj2 = new Guoyansiex ();
Je veux maintenant accéder à l'âge des propriétés du prototype de la classe parent Guoyansi à partir de l'OBJ.
C'est l'idée.
Étape 1: obj2 ====> obj2.constructor.prototype
Partie 2: obj2.constructor.prototype ===> guoyansiex.prototype;
Partie 3: Guoyansiex.prototype ===> OBJ1;
Partie 4: Obj1.Constructor ====> Guoyansi
Partie 5: Guoyansi.prototype.age
Écrivez-le comme ceci: console.log (obj2.constructor.prototype.constructor.prototype.age) // 24;
Le résultat final est 24.
Le résultat final est 24. Il peut être exécuté normalement, mais dans de nombreux livres, il indique qu'après la modification du constructeur, le niveau ne peut pas trouver le prototype de la classe parent. Je ne sais pas ce qui se passe.
Assez d'un attribut plus concis dans firefox._proto_
Par défaut, SpiderMonkey ajoute un attribut appelé _proto_ à tout objet créé, qui pointe vers le prototype utilisé par le constructeur.
En fait, c'est la chaîne prototype invisible que nous avons mentionnée ci-dessus, mais c'est juste une divulgation déguisée à cet endroit.
Vous pouvez accéder à l'âge de cette manière
console.log (obj2 .__ proto __.__ proto __. Âge); // 24
Cela accéde en effet à l'attribut prototype de la classe parent, mais cet attribut ne s'applique qu'à Firefox, et il y aura des erreurs dans d'autres navigateurs.
Dans E5, l'objet est étendu à object.getPrototypeOf (), et vous pouvez accéder à tous les prototypes de classe parent.
La copie de code est la suivante:
fonction guoyansi () {}
Guoyansi.prototype.age = 24;
fonction guoyansiex () {}
var obj1 = new guoyansi ();
Guoyansiex.prototype = obj1;
Guoyansiex.prototype.constructor = guoyansiex; // réinitialiser le pointeur du constructeur.
var obj2 = new Guoyansiex ();
var proto = object.getPrototypeOf (obj2);
while (proto) {
console.log (proto.constructor);
proto = object.getPrototypeOf (proto);
}
console.log ("Prototype d'objet" + proto);
Le résultat est: Guoyansiex
Guoyansi
Objet
Prototype nul pour objet
Je pense personnellement que ceux-ci devraient être considérés comme l'une des essences du JavaScript orienté objet. Veuillez vous référer à cela vous-même et l'utiliser dans votre propre projet en fonction de vos besoins.