L'héritage en JavaScript est assez bizarre. Il ne peut pas implémenter l'héritage de l'interface et ne peut s'appuyer que sur l'héritage du prototype.
Chaîne prototype
Un prototype est un objet. L'instance créée via le constructeur aura un pointeur vers le prototype pour obtenir les propriétés et les méthodes du prototype. De cette façon, l'objet d'instance a la méthode d'attribut du constructeur et la méthode d'attribut du prototype, puis pointe le prototype du constructeur qui doit être hérité de cette instance, afin que toutes les méthodes d'attribut de l'instance puissent être héritées.
Voir le code de démonstration suivant:
// Déclare la superclasse, ajoutez des propriétés et des méthodes pertinentes via les constructeurs et les prototypes fonction super () {this.property = true;} super.prototype.getsupervalue = function () {return this.property;}; // déclare la fonction du constructeur subtype () {this.subproperty = false;} // point le prototype et obtenir tout dans le sous-type Superclass.prototype = new Super (); sous-type.prototype.constructor = sous-type; sous-type.prototype.getsubValue = function () {return this.subproperty;}; // créer un objet à partir d'une sous-classe pour tester si inhérendre les méthodes de superclasse et les attributs var Instructions = new);); console.log (instance.getsupervalue ());Le prototype par défaut de toutes les fonctions est une instance de l'objet, donc le prototype par défaut contiendra un pointeur interne vers objet.prototype.
Utilisez l'instance OFF et ISPrototypeOf pour déterminer la relation entre les prototypes et les instances:
instance instance de l'objet; objet.prototype.isprototypeof (instance);
Lorsque vous utilisez des chaînes prototypes, vous devez définir attentivement la méthode. Les sous-classes doivent réécrire une méthode ou une extension de supertype et doivent être placées après l'énoncé qui remplace le prototype, afin qu'il puisse prendre effet. De plus, lors de l'héritage d'une chaîne prototype, vous ne pouvez pas utiliser les littéraux d'objets pour créer une méthode prototype, qui remplacera la chaîne prototype:
...... sous-type.prototype = new super (); sous-type.prototype = {....};Cela remplace le pointeur pour pointer vers le nouvel objet, en réécrivant la chaîne prototype.
La méthode d'héritage des chaînes prototypes est imparfaite et il y a deux problèmes principaux:
1. À partir d'un prototype contenant la valeur de type de référence, il sera partagé par toutes les instances.
Comme mentionné dans l'article précédent, les attributs prototypes contenant des valeurs de type de référence seront partagés par toutes les instances. Une instance sera modifiée et les autres instances changeront en conséquence. Par conséquent, les attributs doivent être définis dans le constructeur. Lorsque la chaîne prototype hérite, peu importe si les attributs de la superclasse sont définis dans le constructeur ou le prototype, tous deviennent des objets d'instance et sont hérités par les sous-classes, ayant ainsi un impact sur les cas de la sous-classe.
2. Lors de la création d'une instance d'un sous-type, les paramètres ne peuvent pas être transmis au constructeur SuperType.
L'héritage de la chaîne prototype pointe directement le prototype de sous-classe à l'instance de la superclasse, et à ce moment, les paramètres peuvent être transmis à la superclasse. Cependant, lorsqu'une sous-classe crée une instance, elle ne peut transmettre des paramètres qu'au constructeur de la sous-classe, mais pas au constructeur de la superclasse.
Par conséquent, dans les applications pratiques, les chaînes prototypes sont rarement utilisées seule.
Quelques pratiques de code connexes
Identifier un prototype d'attribut
fonction hasprototypeproperty (objet, nom) {nom de retour dans objet &&! object.hasownproperty (name);}Utilisation d'objets prototypes dans les constructeurs
fonction personne (name) {this.name = name;} personne.prototype = {constructeur: personne, SayName: function () {console.log (this.name); }, toString: function () {}}; var person1 = new personne ('nicholas'); var person2 = new personne ('greg); console.log (person1 instanceof personne); // trueconsole.log (personne1.constructor === personne); // trueconsole.log (personne1.constructor === personne); // trueconsole.log (Person1.Constructor === Object); // falseconsole.log (Person2 instanceof personne); // trueconsole.log (Person2.Constructor === personne); // trueconsole.log (Person2.Constructor === Object); // FAUXHéritage d'objet
var person1 = {name: 'Nicholas', SayName: function () {console.log (this.name); }}; var person2 = object.create (personne1, {name: {configurable: true, énumérable: true, value: 'greg', écrivable: true}}); person1.sayName (); // Nicholasperson2.sayName (); // GregConsole.log (Person1.HasownProperty ('SayName')); // trueconsole.log (personne1.ispropertyof (Person2)); // trueconsole.log (Person2.HasownProperty ('SayName')); // FAUXMode module
var person = (function () {var âge = 25; fonction getage () {return age;} function Growolder () {Age ++;} return {name: 'Nicholas', Getage: Getage, Growolder: Growolder};} ());Constructeur de lunettes
fonction personne (name) {this.name = name;} personne.prototype.sayName = function () {console.log (this.name);}; var person1 = personne ('Nicholas'); console.log (person1 instanceof personne); // falseconsole.log (typeof Person1); // undefinedConsole.log (nom); // Nicholas