Explication détaillée des exemples d'utilisation de l'héritage JavaScript : héritage prototypique, héritage parasite et héritage combiné parasite

Héritage prototypique

La méthode de mise en œuvre de l'héritage prototypique est différente de celle de l'héritage prototypique n'utilise pas de constructeurs au sens strict, mais s'appuie sur des prototypes que vous pouvez créer. de nouveaux objets basés sur des objets existants sans avoir à créer de types personnalisés. Le code spécifique est le suivant :

function object(o) {
  function F() {}
  F.prototype = o;
  return new F();
}

Exemple de code :

/* 原型式继承 */
function object(o) {
  function F() {}
  F.prototype = o;
  return new F();
}

var person = {
  name : 'wuyuchang',
  friends : ['wyc', 'Nicholas', 'Tim']
}

var anotherPerson = object(person);
anotherPerson.name = 'Greg';
anotherPerson.friends.push('Bob');

var anotherPerson2 = object(person);
anotherPerson2.name = 'Jack';
anotherPerson2.friends.push('Rose');

alert(person.friends);  // wyc,Nicholas,Tim,Bob,Rose

Parasitique héritage

/* 寄生式继承 */
function createAnother(original) {
  var clone = object(original);
  clone.sayHi = function() {
    alert('hi');
  }
  return clone;
}

Exemple d'utilisation :

/* 原型式继承 */
function object(o) {
  function F() {}
  F.prototype = o;
  return new F();
}
   
/* 寄生式继承 */
function createAnother(original) {
  var clone = object(original);
  clone.sayHi = function() {
    alert('hi');
  }
  return clone;
}

var person = {
  name : 'wuyuchang',
  friends : ['wyc', 'Nicholas', 'Rose']
}
var anotherPerson = createAnother(person);
anotherPerson.sayHi();

Héritage de combinaison parasitaire

L'implémentation de l'héritage en mode combiné en JavaScript a ses propres inconvénients. Nous allons maintenant résoudre ses inconvénients. L'idée d'implémentation est que le constructeur hérite des propriétés et de la méthode d'héritage de forme mixte de la chaîne de prototypes. n'a pas besoin d'être utilisé dans la chaîne de prototypes. Lors de l'héritage d'une méthode, instanciez le constructeur du type parent. Le code est le suivant :

function object(o) {
  function F() {}
  F.prototype = o;
  return new F();
}

/* 寄生组合式继承 */
function inheritPrototype(subType, superType) {
  var prototype = object(superType.prototype);
  prototype.constructor = subType;
  subType.prototype = prototype;
}

Lors de son utilisation, il vous suffit de remplacer la ligne de code "SubType.prototype = new SuperType();" mode de combinaison avecheritatePrototype(subType, superType); c'est tout. La grande efficacité de l’héritage combiné parasite se reflète dans le fait qu’il n’appelle le constructeur de type parent qu’une seule fois, évitant ainsi la création de propriétés inutiles ou redondantes. Dans le même temps, la chaîne de prototypes reste inchangée, donc instanceof et isPrototypeof() peuvent toujours être utilisés normalement. Il s’agit actuellement de la méthode d’héritage la plus idéale et nous sommes actuellement en transition vers ce modèle. (YUI utilise également ce modèle.)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!