条件: 组合指的是什么？就是这两部分的组合：组织函数属性的继续和竖立子类和父类原型的链接。

借用组织函数继续

最简朴的要领，运用call或apply要领，将父对象的组织函数绑定在子对象上

function Super(name){
    this.name=name;
    this.friends = ['小红','小强'];
}
Super.prototype.sayName = function(){
    alert(this.name)
};
function Sub(name){
    Super.apply(this,arguments);
}

var instance1 = new Sub('小明');
var instance2 = new Sub('小明');
instance1.friends.push('张三');
console.log(instance1.friends);//["小红", "小强", "张三"]
console.log(instance2.friends);//["小红", "小强"]

瑕玷: 没办法继续超类中的原型属性和要领

原型链继续

        function Super(){
            this.name="小明";
        }
        Super.prototype.sayName = function(){
            alert(this.name)
        };
        function Sub(){}
        
        Sub.prototype = new Super();
        
        Sub.prototype.constructor = Sub;  
        //此句的作用是为了不让继续链的杂乱,由于任何一个prototype对象都有一个constructor属性，指向它的组织函数,
        //而且每个实例也有一个constructor属性，默许挪用prototype对象的constructor属性,
        //所以new Animal()的constructor指向Super,致使Sub.prototype.constructor改而指向了Super 为了不致使杂乱 所以要手动指回
        
        var instance = new Sub();
        instance.sayName();//小明

瑕玷:
1.当父类中包括援用范例属性值时，个中一个子类的多个实例中，只需个中一个实例援用属性只发作修正一个修正，其他实例的援用范例属性值也会马上发作转变
2.原因是父类的属性变成子类的原型属性

组合式继续
（原型继续+借用组织函数继续）

    
        function Super(){
        this.name="小明";
            this.friends = ['小红','小强'];
        }
        Super.prototype.sayName = function(){
            alert(this.name)
        };
        function Sub(){
            Super.call(this);
        }
        
        Sub.prototype = new Super();
        var instance1 = new Sub();
        var instance2 = new Sub();
        instance1.friends.push('张三');
        console.log(instance1.friends);//["小红", "小强", "张三"]
        console.log(instance2.friends);//["小红", "小强"]
        instance1.sayName();//小明
        instance2.sayName();//小明

瑕玷:
1.两次挪用父组织函数 而且子类的自在属性和原型链上的属性会反复掩盖 (打印instance1对象 instance1.prototype和instance1都有一个name属性)
2.同原型链继续的第一个瑕玷

寄生组合式继续
寄生组合式继续 两步:

1.在子类中挪用父类的组织函数：
  Super.apply(this,arguments)
2.竖立子类和父类原型的链接 
  最简朴的要领就是用Object.create()要领对父类的原型举行浅复制，赋给子类原型：
  Sub.prototype=Object.create(Super.prototype);   //比拟之前的原型链继续要领：SubType.prototype=new SuperType()；这里没有建立组织函数；

    //寄生组合式继续函数
        function inheritPrototype(sub,super){
            var prototype=Object.create(super.prototype) 
            prototype.constructor = sub; //加强对象
            sub.prototype = prototype; //末了指定对象  
        }
   
    //终究的完成要领
        function Super(name){
            this.name=name;
        }
        Super.prototype.sayName=function(){console.log(this.name)}
        
        function Sub(name,age){
            Super.call(this,name);
            this.age=age;
        }
        inheritPrototype(SubType,SuperType); //完成继续
        
        //实在，说白了寄生组合式继续就是一个借用组织函数 + 相当于浅拷贝父类的原型对象

这类体式格局的高效率表现它只挪用了一次Parent组织函数，并不会建立不必要的、过剩的属性。与此同时，原型链还能坚持稳定；开发人员普遍认为寄生组合式继续是援用范例最理想的继续体式格局.