一篇文章教你JS函数继承

一. 前言：

hello，大家最近过得好吗，????。函数继承是在js里比较基础也是比较重要的一部分，而且也是面试中常常要问到的。下面带你快速了解js中有哪几种是经常出现且必须掌握的继承方式。掌握下面的内容面试也差不多没问题啦~

当然，这需要一定的原型链基础，对原型链不熟悉的可以看我这篇文章????：速识js原型链。

二.原型链继承：

原型链继承的要点在于父类的实例作为子类的原型。直接看下面这个例子：

 // 父函数 person
  function person(name, age) {
    // 定义一些属性
    this.name = name;
    this.age = age;
    this.nature = ["auroras", "wind", "moon"];
  }
 // 定义person原型上的一个方法
  person.prototype.saylove = function () {
    console.log(this.name + " like " + this.nature[0]);
  };
  // 子函数 jack
  function jack() {}
  // 父类的实例作为子类的原型 （-------------------实现核心--------------------------）
  jack.prototype = new person();

现在我们创建两个jack 的实例，测试看是否实现了继承person：

      var jack1 = new jack();
      var jack2 = new jack();
      jack2.nature[0] = "sea";
      jack1.saylove();
      jack2.saylove();   
      console.log(jack1.nature);
      console.log(jack2.nature);  

看运行结果确实继承了，能执行saylove方法。但有甚多缺点，创建jack实例的时候传递不了参数name和age，而且不同实例间nature引用类型属性相互影响，一个改变那都改变：

三.借用构造函数继承（对象伪装）：

核心在于“盗用构造函数”（constructor stealing）。在子类构造函数中调用父类构造函数。因为毕竟函数就是在特定上下文中执行代码的简单对象，所以可以使用apply()和call()方法以新创建的对象为上下文执行构造函数。它能解决原型链继承中传参数和引用类型属性冲突。还是直接看例子：

 // 父函数 person
  function person(name, age) {
    // 定义一些属性
    this.name = name;
    this.age = age;
    this.nature = ["auroras", "wind", "moon"];
  }
 // 定义person原型上的一个方法
  person.prototype.saylove = function () {
    console.log(this.name + " like " + this.nature[0]);
  };
  // 子函数 lucy
  function lucy(name, age) {
  // 通过call把this指向lucy，相当于拷贝了一份父函数 person 里的内容（---------实现核心--------------）
        person.call(this, name, age);
      }
  //给子函数原型上也定义一个方法
   lucy.prototype.syaname = function () {
        console.log("my name is " + this.name);
      };

现在我们创建两个lucy 的实例，测试看是否实现了继承person：

      var lucy1 = new lucy("lucy1", "20");
      var lucy2 = new lucy("lucy2", "22");
      lucy2.nature[0] = "sea";
      console.log(lucy1.name);
      console.log(lucy1.nature);
      console.log(lucy2.nature);
      lucy1.syaname();
      lucy2.syaname();
      lucy1.saylove();

结果看可以继承了，能传参数，引用类型属性也不互相影响，但是缺点显而易见，可以看到报错，无法使用父类的原型上的方法saylove。

四.组合继承：

组合继承就是结合了原型链继承和借用构造函数继承两者的核心实现的一种继承方法，既能传递参数，引用类型属性也互不影响，同时子类也能获取得到父类的方法。这也是目前比较常用的继承方式。直接看例子：

 // 父函数 person
  function person(name, age) {
    // 定义一些属性
    this.name = name;
    this.age = age;
    this.nature = ["auroras", "wind", "moon"];
  }
 // 定义person原型上的一个方法
  person.prototype.saylove = function () {
    console.log(this.name + " like " + this.nature[0]);
  };
  // 子函数lisa
      function lisa(name, age) {
// 通过call把this指向lisa，相当于拷贝了一份父函数 person 里的内容（------实现核心-----------）      
        person.call(this, name, age);
      }
// 父类的实例作为子类的原型 （--------------实现核心-------------------）      
      lisa.prototype = new person();
  //小知识点，这里是让lisa的constructor重新指向lisa，不然因为lisa的原型为person实例，constructor会指向person
      lisa.prototype.constructor = lisa;

现在我们创建两个lisa 的实例，测试看是否实现了继承person：

      var lisa1 = new lisa("lisa1", "20");
      var lisa2 = new lisa("lisa2", "21");
      lisa2.nature[0] = "sea";
      console.log(lisa1.name);
      console.log(lisa1.nature);
      console.log(lisa2.nature);
      lisa1.saylove();
      lisa2.saylove();

可以看到基本上实现了我们继承的功能。也修补了原型链和借用构造函数继承的缺点。但是呢，它还是有一个小缺点，就是可以看到在代码注释实现核心那，两次都调用了person，那么lisa原型上和实例上有了两份相同的属性，那就会多少有一些性能浪费。

五.寄生组合继承：

其实寄生组合继承和组合继承差不多的，就是多了一个解决组合继承上原型和实例产生两份相同属性的缺点。解决核心是我们既然只是想要子类原型赋值为父类原型，那没必要new一个父类实例。直接创造一个新对象，它值为父类的原型，再将它赋值给子类原型就行了。

其中用到object.create(proto，[propertiesobject])这个方法创建一个新对象。相当于新对象的__proto__为其参数proto。当然object.create可能低版本ie没有，所以下面也自定义封装了object.create方法，当然只是简单封装。直接看例子：

 // 父函数 person
  function person(name, age) {
    // 定义一些属性
    this.name = name;
    this.age = age;
    this.nature = ["auroras", "wind", "moon"];
  }
 // 定义person原型上的一个方法
  person.prototype.saylove = function () {
    console.log(this.name + " like " + this.nature[0]);
  };
  // 子函数 andy
 function andy(name, age) {
        person.call(this, name, age);
      }
// 如果没有 object.create（）方法，简单封装下
      if (!object.create) {
        object.create = function (proto) {
          function temp() {}
          temp.prototype = proto;
          return new temp();
        };
      }
// 调用object.create方法，新建一对像，其__proto__为person.prototype，并赋值给 andy.prototype (-------实现核心----------)
      andy.prototype = object.create(person.prototype);
  //修改constructor指向
      andy.prototype.constructor = andy;

现在我们创建两个andy的实例，测试看是否实现了继承person：

      console.log(andy.prototype.__proto__ === person.prototype);
      var andy1 = new andy("andy1", "20");
      var andy2 = new andy("andy2", "21");
      andy2.nature[0] = "sea";
      console.log(andy1.name);
      console.log(andy1.nature);
      console.log(andy2.nature);
      andy1.saylove();
      andy2.saylove();

完美运行：

六.class继承：

es6出了class语法糖之后，就可以通过class定义类并实现类的继承。直接看例子：

//定义一个父类 animal
  class animal {
   //这里constructor指向类本身，跟es5行为一样的
    constructor(name) {
      this.name = name;
    }
    likeeat() {
      console.log(this.name + " like eat " + this.food);
    }
  }
//定义一个子类 dog ，通过 extends 继承父类animal
  class dog extends animal {   
    constructor(name, food) {
      //通过super（属性名）继承父类属性
     super(name);
     this.food = food;
    }
    likeeat() {
     //通过super.+父类方法 实现继承父类方法
      super.likeeat();
    }
  }

new一个dog实例，测试看看，dog是否继承了animal：

  var jinmao = new dog("jinmao", "bone");
  console.log(jinmao.name);
  jinmao.likeeat();

可以看到完美实现了：

七.总结：

方法	优点	缺点
原型链继承	能继承父原型上属性方法等等…	无法传参、引用类型属性冲突等等…
借用构造函数继承	可以传参，引用类型属性不冲突等等…	无法继承父原型上方法等等…
组合继承	有上面两种的优点，并解决其缺点	调用两次父实例产生两份相同属性等等…
寄生组合继承	有上面三种优点，并解决其缺点	可能不太直观等等…
class继承	es6新语法，简洁直观等等…	低版本ie不支持es6等等…

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注的更多内容！