| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | function SuperType(){ this .colors=[ "red" , "blue" , "green" ]; } function SubType(){ //继承了SuperType SuperType.call( this ); } var instance= new SubType(); instance.colors.push( "black" ); //"red","blue","green","black" alert(instance.colors); var instance2= new SubType(); alert(instance2.colors); //"red","blue","green" |
将SuperType构造函数放到SubType的执行环境中，这样一来，就会在新SubType对象上执行SuperType()函数中定义的所有对象初始化代码，结果，SubType的每一个实例都有一份具有自己colors属性的副本。
(1)传递参数
借用构造函数可以在子类型构造函数中向父类型构造函数传递参数。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | function SuperType(name){ this .name=name; } function SubType(){ //继承了SuperType,同时传递参数 SuperType.call( this , "zxj" ); //实例属性 this .age=29; } var instance= new SubType(); alert(instance.name); //zxj alert(instance.age); //29 |
(2)借用构造函数的问题
如果仅仅使用借用构造函数，那么将无法避免构造函数模式存在的问题——方法都在构造函数中定义，函数的复用也无从谈起。所以借用构造函数也很少单独使用。
2.组合继承
组合继承(伪经典继承)，指的是将原型链和借用构造函数的技术组合在一块。其思路是使用原型链对原型属性和方法的继承，而通过借用构造函数来实现对实例对象的继承。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | 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 instance= new SubType( "zxj" ,29); instance.colors.push( "black" ); alert(instance.colors); //"red","blue","green","black" instance.sayName(); //zxj instance.sayAge(); //29 var instance2= new SubType( "Greg" ,28); alert(instance.colors); //"red","blue","green","black" instance2.sayName(); //Greg instance2.sayAge(); //28 |
组合继承避免了原型链和借用构造函数的缺陷，融合了他们的有点，成为JavaScript中追尾常用的继承模式。而且，instanceof和isPrototypeof()也能够用于识别组合继承创建的对象。
3.原型式继承
借助原型可以基于已有的对象创建新对象，同时还不必因此创建自定义类型。
| 1 2 3 4 5 | function object(o){ function F(){}; F.prototype=o; return new F(); } |
在object()函数内部，先创建一个临时性的构造函数，然后将传入的对象作为该构造函数的原型，最后返回这个临时类型的一个新实例。本质上讲，object()对传入其中的对象进行了一次浅复制。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | function object(o){ function F(){}; F.prototype=o; return new F(); } var person={ name: "zxj" , friends:[ "Shelby" , "Court" , "Van" ] }; var anotherPerson=object(person); antherPerson.name= "Greg" ; anotherPerson.friends.push( "Rob" ); var yetAnotherPerson=object(person); yetAnotherPerson.name= "Linda" ; yetAnotherPerson.friends.push( "Brabie" ); alert(person.friends); //"Shelby,Court,Van,Rob,Brabie" |
但包含引用类型值的属性始终后悔共享相应的值，这和原型模式一样的。
4.寄生式继承
寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部以某种方式类增强对象，最后再像真的是它做了所有工作一眼放回对象。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | function creteAnother(original){ var clone=object(original); //通过调用函数创建一个新对象 clone.sayHi= function (){ //以某个方式来增强这个对象 alert( "hi" ); } return clone; //返回这个对象 } var person={ name: "zxj" , friends:[ "Shelby" , "Court" , "Van" ] }; var anotherPerson=createAnother(person); anotherPerson.sayHi(); //"hi" |
使用寄生式来为对象添加函数，会由于不能做到函数服用而降低效率。
5.寄生组合式继承
组合继承是JavaScript中最常用的继承模式，但它无论在什么情况下，都会调用两次父类型构造函数：一次在创建子类型原型时，一种在子类型构造函数内部。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | function SuperType(name){ this.name=name; this.colors=[ "red" , "blue" , "green" ]; } 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); } |
第一次调用父类型时，SubType.prototype会得到两个属性：name和colors;他们都是SuperType的实例属性，只不过位于SubType的原型中。带调用SubType构造函数时，有一次调用了SuperType构造函数，这一次是在新对象上创建实例属性name和colors,于是这两个属性就屏蔽掉了原型中的两个同名属性，调用过程如图所示。
这样就有两组name和colors属性：一组在实例上，一组在SubType的原型中，这就是调用两次SuperType构造函数的结果。
当然，我们可以通过寄生组合是继承来解决这问题，所谓寄生组合式继承，即通过借用构造函数来继承属性，通过原型链来继承方法。思路：不必为了指定子类型的原型而调用父类型的构造函数，我们只需父类型原型的一个副本。本质上，就是使用寄生式继承来继承父类型的原型，然后将结果指定给子类型的原型，寄生组合式继承的基本模式如下：
| 1 2 3 4 5 | function inheritPrototype(subType,superType){ var prototype=object(superType.prototype); //创建对象 prototype.constructor=subTyoe; //增强对象 subType.prototype=prototype; //指定对象 } |
示例中inheritPrototype()函数实现了寄生组合式继承的最简单形式。这个函数接收两个参数：子类型构造函数和父类型构造函数。在函数内部：第一步是创建父类型原型的一个副本。第二步是为创建的副本调价constructor属性，从而弥补因重写原型而失去默认的constrcutor属性。最后一步，将新创建的对象(即副本)赋值给子类型的原型。这样，我就可以调用inheritPrototype()函数的语句，去替换前面例子中为子类型原型赋值的语句。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 | function object(o){ function F(){} F.prototype = o; return new F(); } function inheritPrototype(subType, superType){ var prototype = object(superType.prototype); //create object prototype.constructor = subType; //augment object subType.prototype = prototype; //assign object } 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); }; 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 |