JavaScript高级程序设计学习笔记之继承模式

摘要：实现原型链的方式如下让原型对象称为另一个构造函数的实例这个实例继承了的属性上述代码继承是通过来实现，创建的实例，并将该实例赋给。无疑，集两者之大成，这才是最常用的继承模式。

JavaScript的继承主要依靠原型链来实现的。我们知道，构造函数，原型，和实例之间的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个原型对象的指针。

实现原型链的方式如下

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

function  SubType(){
    this.subpropertype=false;
}
//让原型对象称为另一个构造函数的实例
SubType.prototype=new SuperType();

SubType.prototype.getSubValue=function(){
    return this.subpropertype;
};
var  instance=new SubType();
alert(instance.getSuperValue());//true
//这个实例继承了SuperType.prototype的constructor属性？
alert(instance.constructor==SuperType);//true

上述代码继承是通过SubType.prototype=new SuperType();来实现，创建SuperType的实例，并将该实例赋给SubType.prototype。

继承实现的本质是重写原型对象，代之以一个新类型的实例。

下图为构造函数，实例以及原型之间的关系图：

图片描述

原型链顶端:所有引用类型都默认继承Object，所以，所有函数的默认原型都是Object的实例，默认原型都会包含一个内部指针[[prototype]]，指向Object.prototype。

实例属性变为原型属性

function  SuperType(){
    this.color=["red","green","blue"];
}
function  SubType(){

}
SubType.prototype = new SuperType();

var instance1 = new SubType();
instance1.color.push("black");
alert(instance1.color);//"red,green,blue,black"

var instance2 = new SubType();
alert(instance2.color);//"red,green,blue,black"

这个问题似曾相识，正是原型模式创建对象时由于共享引用类型属性，导致牵一发动全身的问题。

在创建子类型时，不能向超类型的构造函数传递参数。

所以，多带带使用原型链情况较少。

针对原型链的第一个问题，我们可采用借用构造函数的技术来解决。基本思想就是在子类型构造函数的内部调用超类型构造函数。看例子：

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

var instance2 = new SubType();
alert(instance2.color);//"red,green,blue"

在新创建的SubType子类型的实例中调用SuperType超类型构造函数，就可以在新的实例对象上执行SuperType()函数中定义的所有对象初始化代码。问题不就解决了吗！
但是，这种模式的缺点是在超类型中定义的方法，对子类型是不可见的，无法实现共享方法。
所以，这种方法也不常用。

组合上述两种方法就是组合继承。用原型链实现对原型属性和方法的继承，用借用构造函数技术来实现实例属性的继承。无疑，集两者之大成，这才是最常用的继承模式。看：

function  SuperType(){
    this.name=name;
    this.color=["red","green","blue"];
}
SuperType.prototype.sayName = function(){
    alert(this.name);
}
function  SubType(name,age){
    //继承了SuperType
    SuperType.call(this,name);
    //自己又添加了一个
    this.age = age;
}
//构建原型链
SubType.prototype = new SuperType();
//重写SubType.prototype的constructor属性，指向自己的构造函数SubType
SubType.prototype.constructor=SubType;
//原型方法，被实例们共享
SubType.prototype.sayAge = function(){
    alert(this.age);
}

var instance1 = new SubType("Nichola",29);
instance1.color.push("black");
alert(instance1.color);//"red,green,blue,black"
instance1.sayName();//"Nichola"
instance1.sayAge();//29

var instance2 = new SubType("Grey",24);
alert(instance2.color);//"red,green,blue"
instance2.sayAge();//24
instance2.sayName();//"Grey"

这个方案已经看似perfect了。但是，后面再说。

借助原型可以基于已有的对象创建新的对象，不必因此创建自定义类型。

function object(o){     //返回一个对象以传入对象为原型
    function F(){}
    F.prototype = o;
    return new F();
}

var person ={
    name:"Nichola",
    friends:["Shelly","Court","Van"]
};
var person1 = object(person);
person1.name = "Grey";
person1.friends.push("Rob");

var person2 = object(person);
person2.name = "Linda";
person2.friends.push("Barble");

alert(person.friends);//"Shelly,Court,Van,Grey,Barble"

使用场合：需求简单，只需要让新对象与已有对象保持相似。优点，不必创建构造函数，缺点，包含引用类型值的属性始终共享相应的值。
Object.create()正是为实现这种模式诞生。

与原型式继承相似，也是基于某个对象或某些信息创建对象，然后增强对象，最后返回对象。实现方法：创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后返回这个对象。看！

function createAnother(original){
    var clone = object(original);//通过调用函数创建对象
    clone.sayHi= function (){    //增强对象
        alert("Hi");
    };
    return clone;//返回对象
}
//可以返回新对象的函数
function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}

var person ={
    name:"Nichola",
    friends:["Shelly","Court","Van"]
};

var anotherPerson = createAnother(person);
anotherPerson.sayHi();//"Hi"

这种继承模式适用的场合：任何返回新对象的函数都可以。缺点是不能做到函数复用。

上面说到组合继承也有缺点，就是无论在何种情况下，都会调用两次超类型构造函数，一次是在创建子类型原型时，还有一次是在子类型构造函数内部。
这种模式集中了寄生式和组合式继承的优点。

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

SubType.prototype.constructor=SubType;

SubType.prototype.sayAge = function(){
    alert(this.age);
}

var instance1 = new SubType("Nichola",29);

第一次调用SuperType():给SubType.prototype写入两个属性name，color
第二次调用SuperType()：给instance1写入两个属性name，color
实例对象instance1上的两个属性就屏蔽了其原型对象SubType.prototype的两个同名属性。所以，组合模式的缺点就是在SubType.prototype上创建不必要的重复的属性。
寄生组合式继承基本模式：

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

首先，创建超类型的一个副本；
其次，为副本添加constructor属性，使其指向子类型构造函数；
最后，将副本赋值给子类型原型。

function  SuperType(){
    this.name=name;
    this.color=["red","green","blue"];
}
function  SubType(){
    SuperType.call(this.name);
    this.age = age;
}
function  inheritPrototype(SubType,SuperType){
    var prototype = object(superType.prototype);//创建对象
    prototype.constructor = SubType;//增强对象
    SubType.prototype = prototype;//制定对象
}
SubType.prototype.sayAge = function(){
    alert(this.age);
}

var instance1 = new SubType("Nichola",29);

借用构造函数来继承实例属性，使用寄生式继承来继承超类型的原型，然后再将结果赋给子类型原型。这样既可以继承超类型的实例属性，也可继承超类型原型中的原型属性。这是最优解。