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。

原型链缺点

  1. 实例属性变为原型属性


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"

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

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

所以,单独使用原型链情况较少。

借用构造函数

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

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);

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

    原文作者:设计模式
    原文地址: https://segmentfault.com/a/1190000007468947
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注