Résumé des six principaux modèles de compétences Javascript Heritage_Javascript

1. Chaîne prototype

function SuperType(){
this.property = true;
}

SuperType.prototype.getSuperValue = function(){
return this.property;
};
function SubType(){
this.subproperty = false;
}
//继承了SuperType
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function (){
return this.subproperty;
};
var instance = new SubType();
alert(instance.getSuperValue()); //true

L'essence de l'implémentation est de remplacer l'objet prototype et de le remplacer par une instance du nouveau type.

2. Emprunter un constructeur

function SuperType(){
this.colors = ["red", "blue", "green"];
}
function SubType(){
//继承了SuperType
SuperType.call(this);
}
var instance1 = new SubType();
instance1.colors.push("black");
alert(instance1.colors); //"red,blue,green,black"
var instance2 = new SubType();
alert(instance2.colors); //"red,blue,green"

Si vous empruntez simplement le constructeur, vous ne pourrez pas éviter les problèmes du modèle de constructeur - les méthodes sont toutes définies dans le constructeur, donc la réutilisation des fonctions est hors de question. De plus, les méthodes définies dans le prototype du supertype ne sont pas visibles par les sous-types, donc tous les types ne peuvent utiliser que le modèle constructeur. Compte tenu de ces problèmes, la technique de l’emprunt aux constructeurs est rarement utilisée seule.

3. Héritage combiné

function SuperType(name){
this.name = name;
this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function(){
alert(this.name);

};
function SubType(name, age){
//继承属性
SuperType.call(this, name);
this.age = age;
}
//继承方法
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
alert(this.age);
};
var instance1 = new SubType("Nicholas", 29);
instance1.colors.push("black");
alert(instance1.colors); //"red,blue,green,black"
instance1.sayName(); //"Nicholas";
instance1.sayAge(); //29
var instance2 = new SubType("Greg", 27);
alert(instance2.colors); //"red,blue,green"
instance2.sayName(); //"Greg";
instance2.sayAge(); //27

Dans cet exemple, le constructeur SuperType définit deux propriétés : le nom et les couleurs. Le prototype de SuperType définit une méthode sayName(). Le constructeur SubType transmet le paramètre name lors de l'appel du constructeur SuperType, puis définit son propre âge d'attribut. Ensuite, l'instance de SuperType est affectée au prototype de SubType, puis la méthode sayAge() est définie sur le nouveau prototype. De cette manière, deux instances SubType différentes peuvent avoir leurs propres propriétés, y compris la propriété colours, et peuvent utiliser la même méthode.

L'héritage combiné évite les défauts des chaînes de prototypes et des constructeurs empruntés, combine leurs avantages et devient le modèle d'héritage le plus couramment utilisé en JavaScript. De plus, instanceof et isPrototypeOf() peuvent également être utilisés pour identifier des objets créés sur la base d'un héritage combiné.

4. Héritage prototype

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

Dans la fonction object(), un constructeur temporaire est d'abord créé, puis l'objet transmis est utilisé comme prototype de ce constructeur, et enfin une nouvelle instance de ce type temporaire est renvoyée. Essentiellement, object() effectue une copie superficielle de l'objet qui lui est transmis. Considérez l'exemple suivant.

var person = {
name: "Nicholas",
friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = object(person);
anotherPerson.name = "Greg";
anotherPerson.friends.push("Rob");
var yetAnotherPerson = object(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.friends.push("Barbie");
alert(person.friends); //"Shelby,Court,Van,Rob,Barbie"

L'héritage prototypique prôné par Crockford exige que vous ayez un objet pouvant servir de base à un autre objet. S'il existe un tel objet, vous pouvez le transmettre à la fonction object(), puis modifier l'objet obtenu en fonction de besoins spécifiques. Dans cet exemple, l'objet personne peut être utilisé comme base pour un autre objet, nous le transmettons donc à la fonction object(), qui renvoie ensuite un nouvel objet. Ce nouvel objet utilise la personne comme prototype, son prototype contient donc une propriété de valeur de type de base et une propriété de valeur de type de référence. Cela signifie que person.friends n'appartient pas seulement à une personne, mais est également partagé par une autre personne et pourtant une autre personne. En fait, cela équivaut à créer deux copies supplémentaires de l’objet personne.

ECMAScript 5 standardise l'héritage prototypique via la nouvelle méthode Object.create(). Cette méthode accepte deux paramètres : un objet à utiliser comme prototype du nouvel objet et (éventuellement) un objet pour définir des propriétés supplémentaires pour le nouvel objet. La méthode Object.create() se comporte de la même manière que la méthode object() lorsqu'un paramètre est transmis.

var person = {
name: "Nicholas",
friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = Object.create(person);
anotherPerson.name = "Greg";
anotherPerson.friends.push("Rob");
var yetAnotherPerson = Object.create(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.friends.push("Barbie");
alert(person.friends); //"Shelby,Court,Van,Rob,Barbie"

Le deuxième paramètre de la méthode Object.create() a le même format que le deuxième paramètre de la méthode Object.defineProperties() : chaque propriété est définie via son propre descripteur. Toute propriété spécifiée de cette manière remplace la propriété du même nom sur l'objet prototype. Par exemple :

var person = {
name: "Nicholas",
friends: ["Shelby", "Court", "Van"]
};

var anotherPerson = Object.create(person, {
name: {
value: "Greg"
}
});
alert(anotherPerson.name); //"Greg"

Les navigateurs prenant en charge la méthode Object.create() incluent IE9, Firefox 4, Safari 5, Opera 12 et Chrome.

L'héritage prototypique est parfaitement adéquat lorsqu'il n'est pas nécessaire de faire de grands efforts pour créer un constructeur, mais que vous souhaitez simplement conserver un objet similaire à un autre objet. Mais n'oubliez pas que les propriétés contenant des valeurs de type référence partageront toujours la valeur correspondante, tout comme si vous utilisiez le modèle prototype.

5. Héritage parasitaire

L'héritage parasitaire est une idée étroitement liée à l'héritage prototypique et a également été popularisée par Crockford. L'idée de l'héritage parasite est similaire au constructeur parasite et au modèle d'usine, c'est-à-dire créer une fonction juste pour encapsuler le processus d'héritage, qui améliore l'objet d'une manière ou d'une autre en interne et agit finalement comme s'il faisait vraiment tout le travail. Objet de retour. Le code suivant illustre le modèle d'héritage parasite.

function createAnother(original){
var clone = object(original); //通过调用函数创建一个新对象
clone.sayHi = function(){ //以某种方式来增强这个对象
alert("hi");
};
return clone; //返回这个对象
}

Dans cet exemple, la fonction createAnother() reçoit un paramètre, qui est l'objet qui sera utilisé comme base pour le nouvel objet. Ensuite, transmettez cet objet (original) à la fonction object() et attribuez le résultat renvoyé au clone. Ajoutez ensuite une nouvelle méthode sayHi() à l'objet clone, et enfin renvoyez l'objet clone. Vous pouvez utiliser la fonction createAnother() comme suit :

var person = {
name: "Nicholas",
friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = createAnother(person);
anotherPerson.sayHi(); //"hi"

这个例子中的代码基于person 返回了一个新对象——anotherPerson。新对象不仅具有person的所有属性和方法，而且还有自己的sayHi()方法。
在主要考虑对象而不是自定义类型和构造函数的情况下，寄生式继承也是一种有用的模式。前面示范继承模式时使用的object()函数不是必需的；任何能够返回新对象的函数都适用于此模式。

使用寄生式继承来为对象添加函数，会由于不能做到函数复用而降低效率；这一
点与构造函数模式类似。

6.寄生组合式继承

前面说过，组合继承是JavaScript 最常用的继承模式；不过，它也有自己的不足。组合继承最大的问题就是无论什么情况下，都会调用两次超类型构造函数：一次是在创建子类型原型的时候，另一次是在子类型构造函数内部。没错，子类型最终会包含超类型对象的全部实例属性，但我们不得不在调用子类型构造函数时重写这些属性。再来看一看下面组合继承的例子。

function SuperType(name){
this.name = name;
this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function(){
alert(this.name);
};
function SubType(name, age){
SuperType.call(this, name); //第二次调用SuperType()
this.age = age;
}
SubType.prototype = new SuperType(); //第一次调用SuperType()
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
alert(this.age);
};

加粗字体的行中是调用SuperType 构造函数的代码。在第一次调用SuperType 构造函数时，SubType.prototype 会得到两个属性：name 和colors；它们都是SuperType 的实例属性，只不过现在位于SubType 的原型中。当调用SubType 构造函数时，又会调用一次SuperType 构造函数，这一次又在新对象上创建了实例属性name 和colors。于是，这两个属性就屏蔽了原型中的两个同名属性。图6-6 展示了上述过程。
如图6-6 所示，有两组name 和colors 属性：一组在实例上，一组在SubType 原型中。这就是调用两次SuperType 构造函数的结果。好在我们已经找到了解决这个问题方法——寄生组合式继承。

所谓寄生组合式继承，即通过借用构造函数来继承属性，通过原型链的混成形式来继承方法。其背后的基本思路是：不必为了指定子类型的原型而调用超类型的构造函数，我们所需要的无非就是超类型原型的一个副本而已。本质上，就是使用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。寄生组合式继承的基本模式如下所示。

function inheritPrototype(subType, superType){
var prototype = object(superType.prototype); //创建对象
prototype.constructor = subType; //增强对象
subType.prototype = prototype; //指定对象
}

这个示例中的inheritPrototype()函数实现了寄生组合式继承的最简单形式。这个函数接收两个参数：子类型构造函数和超类型构造函数。在函数内部，第一步是创建超类型原型的一个副本。第二步是为创建的副本添加constructor 属性，从而弥补因重写原型而失去的默认的constructor 属性。最后一步，将新创建的对象（即副本）赋值给子类型的原型。这样，我们就可以用调用inherit-Prototype()函数的语句，去替换前面例子中为子类型原型赋值的语句了，例如

function SuperType(name){
this.name = name;
this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function(){
alert(this.name);
};
function SubType(name, age){
SuperType.call(this, name);
this.age = age;
}
inheritPrototype(SubType, SuperType);
SubType.prototype.sayAge = function(){
alert(this.age);
};

这个例子的高效率体现在它只调用了一次SuperType 构造函数，并且因此避免了在SubType.prototype 上面创建不必要的、多余的属性。与此同时，原型链还能保持不变；因此，还能够正常使用instanceof 和isPrototypeOf()。开发人员普遍认为寄生组合式继承是引用类型最理想的继承范式。

YUI 的YAHOO.lang.extend()方法采用了寄生组合继承，从而让这种模式首次出现在了一个应用非常广泛的JavaScript 库中。要了解有关YUI 的更多信息，请访问http://developer. yahoo.com/yui/。

以上所述就是本文的全部内容了，希望对大家学习javascript继承有所帮助。