浅显易懂的JS继承

1.用原型链继承   (要注意的是：在引用数据类型中push进去一个东西会改变原数组)

 function parent(name, age) { //声明一个父函数，并在里面设置一些属性
        this.name = name
        this.age = age
        this.hobby = ['足球', '篮球', '乒乓球']
    }

    function son() {} //声明一个子函数
    son.prototype = new parent('zhansan', 18) //让子函数的原型被父函数赋值
    let B = new son()    //声明一个构造子函数
    let BSon = new son()
    BSon.name = 'lisi' //直接等号赋值不会改变原数组，因为这是基本数据类型
    BSon.hobby = ['无']  //这里虽然是引用数据类型，但是直接等号赋值也不会改变原数组    
    BSon.hobby.push('唱歌')  //添加一项的话会改变原数组
 

2.用构造函数继承   （直接push不会改变原数组，直接赋值也不会）

// //2.构造函数继承
    function parent() {
        this.name = 'zhangsan'
        this.age = 18
        this.hobby = ['足球', '篮球', '乒乓球']
    }

    function son() {
        parent.call(this) //修改this指向，指向son
    }
    let B = new son()
    let Bb = new son()
    B.hobby.push('唱歌')  //直接push不会改变原数组
    console.log(B);
    console.log(Bb);

3.组合式继承   （直接push不会改变原数组，直接赋值也不会）

就是有个缺点

• 相当于parent被实例化了两次，性能方面受到影响

 function parent() {
        this.name = 'zhangsan'
        this.age = 18
        this.hobby = ['足球', '篮球', '乒乓球']
    }
    parent.prototype.value = function() {  //在原型上设置一个函数
        console.log(this.name + this.age);
    }

    function son() {
        parent.call(this)     //让父函数的this指向son
    }
    son.prototype = new parent()    //让子函数的原型被父函数赋值
    B.hobby = ''    //直接赋值引用数据类型不会改变原数组
    B.hobby.push('唱歌')  //直接push引用数据类型也不会改变原数组
    Ba.value()       //调用一下

 4.寄生组合式继承 

 这种方法是组合式继承延展的，最大的区别就是在创建构造函数的时候把它替换为直接创建了一个对象（直接push不会改变原数组，直接赋值也不会）

 function parent() {
        this.name = 'zhangsan'
        this.age = 18
        this.hobby = ['足球', '篮球', '乒乓球']
    }
    parent.prototype.value = function() {  //在原型上设置一个函数
        console.log(this.name + this.age);
    }

    function son() {
        parent.call(this)     //让父函数的this指向son
    }
    son.prototype = Object.create(parent.prototype)//直接创建一个父函数原型赋值给子函数原型
    B.hobby = ''    //直接赋值引用数据类型不会改变原数组
    B.hobby.push('唱歌')  //直接push引用数据类型也不会改变原数组
    Ba.value()       //调用一下