Comment implémenter l’héritage en javascript ? Une brève analyse de diverses méthodes

Avant de parler d'héritage en JavaScript, nous devons d'abord comprendre ce qu'est une classe. Dans les langages de programmation courants, tels que Java, C++, C#, etc., une classe est une structure de programme utilisée pour encapsuler des données et des méthodes. Des objets peuvent être créés par instanciation pour réaliser la réutilisation et l'abstraction du code.

Mais en JavaScript, la façon dont les classes sont définies et utilisées est légèrement différente des autres langages. Les classes JavaScript sont basées sur des objets et les objets sont au centre du langage. JavaScript n'a pas un système d'héritage de classe aussi compliqué, et toutes les classes peuvent être héritées, c'est-à-dire qu'à l'exception de certains objets intégrés spécifiques, tels que Math, Date, etc., la plupart des objets en JavaScript peuvent servir de classes de base. .

En JavaScript, l'héritage a les méthodes suivantes :

1. Héritage de chaîne de prototypes :

L'héritage de chaîne de prototypes est la méthode d'héritage la plus basique en JavaScript. Utilisez des prototypes pour implémenter l'héritage de fonctions et de propriétés des classes parentes. En termes simples, le prototype de la sous-classe pointe vers l'instance de la classe parent, réalisant ainsi l'héritage. De cette façon, vous pouvez étendre la classe parent et ajouter de nouveaux attributs et méthodes.

Par exemple :

function Animal() {
  this.species = "动物";
}

function Cat(name, color) {
  this.name = name;
  this.color = color;
}

Cat.prototype = new Animal();  // 将 Cat 的原型对象指向 Animal 的实例

var cat1 = new Cat('小红', '黑色');
console.log(cat1.species);  // 输出 "动物"

2. Héritage de constructeur emprunté :

L'héritage de constructeur emprunté, également appelé héritage classique ou héritage de constructeur volé, fait référence à l'appel du constructeur de la classe parent dans le constructeur de la sous-classe pour obtenir l'héritage . Cette méthode est différente de l'héritage de chaîne de prototypes. Elle peut hériter des attributs de la classe parent et obtenir l'indépendance des attributs.

Par exemple :

function Animal(name, color) {
  this.name = name;
  this.color = color;
}

function Cat(name, color) {
  Animal.call(this, name, color);  // 在 Cat 类的构造函数中调用 Animal 类的构造函数
}

var cat1 = new Cat('小红', '黑色');
console.log(cat1.name);   // 输出 "小红"
console.log(cat1.color);  // 输出 "黑色"

3. Héritage combiné :

L'héritage combiné fait référence à la combinaison de l'héritage de chaîne de prototype et de l'héritage de constructeur emprunté, afin que vous puissiez hériter des propriétés et des méthodes de la classe parent en même temps, et vous peut utiliser les propriétés de la classe et des méthodes parent.

Par exemple :

function Animal(name, color) {
  this.name = name;
  this.color = color;
}

Animal.prototype.eat = function() {
  console.log('我是一只动物，我可以吃东西！');
}

function Cat(name, color) {
  Animal.call(this, name, color);
}

Cat.prototype = new Animal();
Cat.prototype.constructor = Cat;

var cat1 = new Cat('小红', '黑色');
console.log(cat1.name);   // 输出 "小红"
console.log(cat1.color);  // 输出 "黑色"
cat1.eat();              // 输出 "我是一只动物，我可以吃东西！"

4. Héritage parasite :

L'héritage parasite fait référence à la création d'une fonction juste pour encapsuler le processus d'héritage, dans lequel l'objet est amélioré d'une manière ou d'une autre, et renvoie finalement cet objet. Cet objet peut être utilisé comme objet prototype pour les sous-classes afin d'obtenir l'héritage.

Par exemple :

function Animal(name) {
  var obj = {
    name: name,
    eat: function() {
      console.log('我是一只动物，我可以吃东西！');
    }
  };
  return obj;
}

function Cat(name, color) {
  var animal = Animal.call(this, name);
  animal.color = color;
  return animal;
}

var cat1 = new Cat('小红', '黑色');
console.log(cat1.name);   // 输出 "小红"
console.log(cat1.color);  // 输出 "黑色"
cat1.eat();              // 输出 "我是一只动物，我可以吃东西！"

5. Héritage combiné parasitaire :

L'héritage combiné parasitaire fait référence à l'optimisation des performances d'héritage des objets grâce à l'héritage parasitaire sur la base de l'héritage combiné. L'héritage peut être obtenu en créant un nouvel objet qui hérite du prototype de la classe parent, évitant ainsi les pièges liés à l'initialisation de l'objet lors de l'appel du constructeur de la classe parent.

Par exemple :

function Animal(name) {
  this.name = name;
}

Animal.prototype.eat = function() {
  console.log('我是一只动物，我可以吃东西！');
};

function Cat(name, color) {
  Animal.call(this, name);
  this.color = color;
}

Cat.prototype = Object.create(Animal.prototype);
Cat.prototype.constructor = Cat;

var cat1 = new Cat('小红', '黑色');
console.log(cat1.name);   // 输出 "小红"
console.log(cat1.color);  // 输出 "黑色"
cat1.eat();              // 输出 "我是一只动物，我可以吃东西！"

En résumé, l'héritage JavaScript peut être implémenté de différentes manières. Dans le développement réel, vous devez choisir la méthode appropriée en fonction de scénarios et de besoins spécifiques.

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!