javascript继承的三种模式

javascript继承一般有三种模式：组合继承，原型式继承和寄生式继承；

1组合继承：javascript最为广泛的继承方式通过原型链实现对原型属性和方法的继承，通过构造函数实现对实例属性的继承，同时发挥两者的优越性。

<script>
function supertype(name){//父类型的构造函数
        	this.name=name;
        	this.colors=["blue","yellow","red"];
        }
        supertype.prototype.sayname=function(){//父类型的原型
        	alert(this.name);
        }
        function subtype(name){
        	   supertype.call(this,name);//通过call函数实现了向父类型的构造函数中传参
        	   this.age=13;
        }
        subtype.prototype=new supertype();//通过原型链继承了supertype实例中的所有属性和方法
        var instance1=new subtype("彭湖湾");

        alert(instance1.name);//输出彭湖湾
        instance1.colors.push("black");
        alert(instance1.colors);//输出为blue,yellow,red，black

        var instance2=new subtype("小明");
        alert(instance2.name);//输出为小明
        alert(instance2.colors);//输出为blue,yellow,red
</script>

　　

在组合继承的过程中，首先调用了call()函数继承了父类型的构造函数的所有属性（又叫做伪继承），这样做有两个好处

1：克服了纯粹只使用原型链继承不能直接传参的缺陷，比如上面subtype继承supertype后能够在创建实例时传入自己的name参数，如果单纯使用原型式继承则不能做到这一点。

2：如果只使用原型链进行继承，实例中的引用类型的属性比如Array,Date,Function等属性是共用的，使用时将非常麻烦。但组合继承中由于通过call()方法继承了父类型的构造函数，新添加的属性将覆盖掉原本共用的引用类型属性。举个例子，在上面的代码中instance1.colors和instance2.colors输出分别为blue,yellow,red，black和blue,yellow,red，在两个实例中colors数组属性是相互独立的，但如果去掉

supertype.call(this,name);//通过call函数实现了向父类型的构造函数中传参
this.age=13;

这一段代码的话，实例的colors属性的输出结果将变成：

        instance1.colors.push("black");
        alert(instance1.colors);//输出为blue,yellow,red，black

        var instance2=new subtype("小明");
        alert(instance2.colors);//输出为blue,yellow,red，black

　　

instance1对colors数组属性添加“Black”的操作同时对instance2的的属性造成了影响，这表明，如果只使用原型链继承的话，colors属性是子类型的实例所共用的

二：原型式继承：仅借助原型基于已有的对象创建新的副本对象

<script>
function object(o){//o为一个以对象字面量形式定义的对象
        function new_object(){};//通过构造函数形式创建一个新对象
        new_object.prototype=o;//使新对象的原型等于传入的对象
        return new new_object();//返回新对象的实例
   }
   var person={//创建一个person对象
       name:"彭湖湾",
       age:,
       friends:["a","b","c"]
   };
   var person1=object(person);//根据person对象创建一个实例person1
   person1.name="小明";
   person1.friends.push("d");
   alert(person1.name);//输出为小明
   alert(person1.friends);//输出为a,b,c,d
   var person2=object(person);//根据person对象创建一个实例person2
   alert(person2.name);//输出为彭湖湾
   alert(person2.friends);//输出为a,b,c,d
</script>

基本的思想和工厂模式相类似，声明一个以一个字面量对象为参数的函数，并将其作为新对象的原型，最后将新对象的实例返回

原型式继承的优点：能实现函数复用，能创建大量相似的对象

原型式继承的缺点:正如上文所说：在原型式继承中，在创建子类型实例时，子类型实例的基本类型属性（如boolean,number,string）可以分别指定不同的新值，但引用类型（Array,Date,Function,Object）的属性则在各个子类型实例中是共享的

三.寄生式继承：和原型式继承类似，但在函数内部通过某些方式来增强对象：

<script>
unction createanother(o){
         var new_object=Object(o);//通过调用函数复制一个副本对象
         new_object.sayhi=function(){//以某种方式来增强这个对象
             alert("hi");
         }
         return new_object;//返回该副本对象
     }
     var person={//创建一个person对象
         job:"student"
     }
     var person2=createanother(person);
     person2.sayhi();
</script>