js的几种继承方式

1.1借用构造函数

 function supertype(){
             this.colors = ["red","blue","green"];
         }
         function subtype(){
             supertype.call(this);
         }
         
         var instance1 = new subtype();
         instance1.colors.push('black');
         console.log(instance1.colors); 
         var instance2 = new subtype();
         console.log(instance2.colors); 

1.2.相对于原型链而言，借用构造函数有一个很大的优势，即可以在子类型构造函数中向超类型构造函 数传递参数。

function supertype(name){
             this.name = name;
         }
         function subtype(){
             supertype.call(this,"gaoxuerong");
             this.age = 21;
         }
         var instance1 = new subtype();         
         console.log(instance1.name);          
         console.log(instance1.age); 

2.组合继承:指的是将原型链和借用构造函数的 技术组合到一块，从而发挥二者之长的一种继承模式。其背后的思路是使用原型链实现对原型属性和方 法的继承，而通过借用构造函数来实现对实例属性的继承。这样，既通过在原型上定义方法实现了函数 复用，又能够保证每个实例都有它自己的属性.

 function supertype(name){
             this.name = name;
             this.colors = ['red','green','black'];
         }
         supertype.prototype.sayname = function(){
             console.log(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(){
             console.log(this.age);
         }
         var instance1 = new subtype('gaoxuerong',21);
         instance1.colors.push('green');
          console.log(instance1.colors); 
         console.log(instance1.sayname());          
         console.log(instance1.sayage()); 
          var instance2 = new subtype('gxr',22);
         console.log(instance2.colors);          
          console.log(instance2.sayname());          
         console.log(instance2.sayage()); 

 

3.原型式继承:

function object(o){
             function F(){}
             F.prototype = o;
             return new F();
         }
         var person = {
             name:'gxr',
             friends:['1','2','3']
         }
         var anotherperson = object(person);
         anotherperson.friends.push('4');
         console.log(anotherperson.name); 
         console.log(anotherperson.friends);
          var yetanotherperson = object(person);
         yetanotherperson.name = 'g';
         yetanotherperson.friends.push('5');
         console.log(yetanotherperson.name);
         console.log(yetanotherperson.friends);

4.寄生式继承

function object(o){
             function F(){}
             F.prototype = o;
             return new F();
         }
         function createanother(original){
             var clone = object(original);
             clone.sayHi = function(){
                 console.log('hi');
             }
             return clone;
         }
         var person = {
             name:'gxr',
             friends:['1','2','3']
         }
         var anotherperson = createanother(person);
         anotherperson.sayHi();

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

 

function object(o){
             function F(){}
             F.prototype = o;
             return new F();
         }
         function inheritprototype(subtype,supertype){
             var prototype = object(supertype.prototype);
             prototype.constructor = subtype;
             subtype.prototype = prototype;
         }
         function supertype(name){
             this.name = name;
             this.colors = ['red','green','black'];
         }
         supertype.prototype.sayname = function(){
             console.log(this.name)
         }
         function subtype(name,age){
             supertype.call(this,name);
             this.age = age;
         }
         inheritprototype(subtype,supertype);
         subtype.prototype.sayage  =  function(){
             console.log(this.age);
         }