js继承 原型链+构造函数+组合继承法

 
    //继承方法之原型链
    function A() {    //创建一个原型对象A，有属性和方法
        this.judge=true;
    }
    A.prototype.value=function () {
        return this.judge
    };

    function B() {   //创建B，属性和A不相同
        this.judge=false;
    }
    B.prototype = new A();    // B继承A
    B.prototype.value=function () {
        return this.judge
    };

    var p=new B;  //创建一个实例p,
    console.log(p.value())  //false   因为p的原型是B，B的属性值为false，如果B里没有定义属性，则会继续向B 的原型A上去找，那就返回true.

总结：通过原型链实现继承时，不能使用对象字面量创建原型方法，那样会重写原型链。此外，原型上的属性会被多个实例共享，而且不能传参数。

 //继承方法之借用构造函数
    function P1() {
        this.colors=["red","blue"]
    }
    function P2() {
         P1.call(this)  //通过call方法继承P1
     }
     var s=new P2();
    s.colors.push("pink"); //向实例s的colors里添加一个pink颜色
    console.log(s.colors);  //打印出来red blue pink

    var b=new P2();  //创建一个b实例
    console.log(b.colors)   //打印b实例的颜色属性，只有red和blue，不会受到第一个实例的影响

总结：优点：实例不会互相干扰，在继承时还可以传递参数；弊端：函数方法都是在构造函数中定义的，因此函数的复用比较困难，很少单独使用。

   function A(name) {   //创建原型A
        this.name=name;   //两个属性
        this.colors=["red","blue"]
    }
    A.prototype.fuck=function () {  //一个方法
        alert(this.name)
    };
    
    function B(name,age) {
        A.call(this,name);  //继承A的属性
        this.age=age;     //传参并有自己的属性
    }
    B.prototype = new A();   //继承方法
    B.prototype.constructor=B;  //将指针改为B自身
    B.prototype.say=function () {
        alert(this.age)
    };

    var person1=new B("Bob",20);   //实例1
    person1.colors.push("yellow");
    console.log(person1.colors);  //["red","blue","yellow"]
    person1.fuck();   //Bob
    person1.say();    //20

    var person2=new B("john",18);  //实例2
    console.log(person2.colors);  //["red","blue"]
    person2.fuck();   //john
    person2.say();    //18

总结：组合继承法融合了前两种方法的优点，使用率最高，最稳当。