En JavaScript, nous pouvons utiliser des prototypes pour atteindre l'héritage.
Par exemple
fonction baz () {this.oo = "";} fonction foo () {} foo.prototype = new baz (); var myfoo = new foo (); myfoo.oo;De cette façon, nous pouvons accéder à l'attribut OO dans Baz. Cela n'est pas possible dans une utilisation réelle, en raison des caractéristiques de partage du prototype (les données sont enregistrées sur le tas),
Toutes les instances utilisent un prototype, mais une fois que l'attribut BAZ a un type de référence, il sera tragique. Si une instance est modifiée, l'autre instance changera également ... wuwuwu
Il y aura naturellement une héritage combinée
fonction baz () {this.oo = "";} baz.prototype.xx = function () {} function foo () {baz.call (this); // le deuxième appel} foo.prototype = new baz (); // le premier appel var myfoo = new foo (); myfoo.oo; myfoo.xx;Cela aura un problème, et le code montre également que Baz sera appelé deux fois. Comment la Vierge peut-elle le permettre?
Si vous ajoutez une phrase, la deuxième méthode n'a-t-elle pas besoin d'avoir le problème avec la première méthode? La réponse est non.
La raison en est que la recherche d'attributs commence par l'objet lui-même. Ce n'est que lorsqu'il ne sera trouvé qu'il sera trouvé qu'il sera trouvé dans le prototype. Lors de l'appel, les attributs sont hérités.
Permettez-moi d'ajouter une autre phrase, alors ne suffira-t-il pas d'utiliser l'héritage des appels comme celui-ci? Ceci est possible si vous n'utilisez pas de prototype, mais comment ne pas utiliser un prototype comme Vierge?
La méthode est partagée sur le prototype, donc les performances seront bien meilleures.
Héritage de combinaison parasite
__extendStend = function (p, c) {function ctor () {this.constructor = c; // Constructeur d'attribution} ctor.prototype = p.prototype; c.prototype = new ctor ();} fonction baz () {this.oo = [1];} baz.prototype.xx = fonction () {} __ extend (baz, foo); foo () {baz.call (this);} var myfoo = new foo (); myfoo.oo; myfoo.xx;Cela résout non seulement le problème de deux appels, mais résout également le problème que lorsque l'objet appelle le constructeur, la fonction réelle qui crée l'objet est appelée à la place d'autres constructeurs sur la chaîne prototype.
Il y a une instruction dans le code.
Le constructeur est un attribut sur l'objet Prototype et est le créateur de l'objet. Étant donné que nos attributs prototypes sont réaffectés, le constructeur est hérité.
Ici, je veux parler de la façon dont les objets sont créés, c'est-à-dire ce que le nouveau a fait.
Par exemple:
var a = new b ();
En fait, c'est comme ça, a = {}; crée un pour a, puis b.call (a); L'appel initialise a. Il y a une autre étape avant l'appel, qui est l'objet prototype interne de a.
Le prototype s'oppose sur lequel la propriété Prototype s'est définie sur B Il existe un attribut de constructeur sur le prototype, qui est utilisé pour créer des contrôles de mémoire d'allocation d'objets.
C'est probablement tout ... il est encore en retard, cassons-le. Gardez un esprit calme et ne soyez pas impatient. Travaillez dur pour changer demain et espérez que tout ira progressivement.
Ce qui précède est tout le contenu que l'éditeur vous apporte sur la compréhension complète de l'héritage (incontournable) en JavaScript. J'espère que tout le monde soutiendra davantage les pas.