原型继承、借用构造函数继承、组合继承

---

前言

ES6之前并没有给我们提供extends继承。我们可以通过构造函数+原型对象模拟实现继承，被称为组合继承。组合继承是js中最常用的继承方式

---

一、call()

某个函数fun.call，由此可以调用这个函数fun，并且修改了这个函数的this指向

代码如下（示例）：

        function fn(x, y) {
            console.log('我想喝手磨咖啡');
            console.log(this);
            console.log(x + y);
        }
        var o = {
            name: 'andy'
        };
         fn();//最早调用函数的方式
        //  call() 可以调用函数
         fn.call();//call作用1：可以调用函数
        // call作用2: call() 可以改变这个函数的this指向 此时这个函数的this 就指向了o这个对象
        fn.call(o, 1, 2);

二、借用构造函数继承父类型属性

核心原理:通过call)把父类型的this 指向子类型的this，这样就可以实现子类型继承父类型的属性。
代码如下（示例）：

        // 借用父构造函数继承属性
        // 1. 父构造函数
        function Father(uname, age) {
            // this 指向父构造函数的对象实例
            this.uname = uname;
            this.age = age;
        }
        // 2 .子构造函数 
        function Son(uname, age, score) {
            // this 指向子构造函数的对象实例
            Father.call(this, uname, age);
            this.score = score;
        }
        var son = new Son('刘德华', 18, 100);
        console.log(son);

三、借用原型对象继承父类方法

问题

代码如下（示例）：

        function Father(uname, age) {
            // this 指向父构造函数的对象实例
            this.uname = uname;
            this.age = age;
        }
        Father.prototype.money = function() {
            console.log(100000);
        };
        // 2 .子构造函数 
        function Son(uname, age, score) {
            // this 指向子构造函数的对象实例
            Father.call(this, uname, age);
            this.score = score;
        }
        Son.prototype = Father.prototype;  
        var son = new Son('刘德华', 18, 100);
        console.log(son);

运行结果

缺陷：如果给子构造函数加上自己的方法

代码如下（示例）：

        function Father(uname, age) {
            this.uname = uname;
            this.age = age;
        }
        Father.prototype.money = function() {
            console.log(100000);
        };
        function Son(uname, age, score) {
            Father.call(this, uname, age);
            this.score = score;
        }
        Son.prototype = Father.prototype;  
       // 这个是子构造函数专门的方法
        Son.prototype.exam = function() {
            console.log('孩子要考试');
        }
        var son = new Son('刘德华', 18, 100);
        console.log(son);
        console.log(Father.prototype);

运行结果

显示父构造函数也有会exam方法，原因是Son.prototype = Father.prototype; 子原型对象指向了复原型对象，改变了子原型对象，从而会一起改变父原型对象。指向，改子等于父。

      Son.prototype = Father.prototype;
        // 这样直接赋值会有问题, 如果修改了子原型对象, 父原型对象也会跟着一起变化

解决

        function Father(uname, age) {
            // this 指向父构造函数的对象实例
            this.uname = uname;
            this.age = age;
        }
        Father.prototype.money = function() {
            console.log(100000);

        };
        // 2 .子构造函数 
        function Son(uname, age, score) {
            // this 指向子构造函数的对象实例
            Father.call(this, uname, age);
            this.score = score;
        }
        Son.prototype = new Father();//原型链
        // 如果利用对象的形式修改了原型对象,别忘了利用constructor 指回原来的构造函数
        Son.prototype.constructor = Son;
        Son.prototype.exam = function() {
            console.log('孩子要考试');

        }
        var son = new Son('刘德华', 18, 100);
        console.log(son);
        console.log(Father.prototype);

运行结果，显示也不会影响父构造函数的原型

如果利用对象的形式修改了原型对象,别忘了利用constructor 指回原来的构造函数，Son.prototype.constructor = Son;Son原型对象重新指回到本身的构造函数，打印结果：

console.log(Son.prototype.constructor);

四、总结