在阅读文章之前，您最少需要对JavaScript原型继续有肯定相识，假如以为有所短缺，能够先相识下我这篇文章：
https://segmentfault.com/a/11…

1.es6 class 运用

javascript运用的是原型式继续，我们能够经由过程原型的特征完成类的继续，
es6为我们供应了像面向对象继续一样的语法糖。

class Parent {
  constructor(a){
    this.filed1 = a;
  }
  filed2 = 2;
  func1 = function(){}
}

class Child extends Parent {
    constructor(a,b) {
      super(a);
      this.filed3 = b;
    }
  
  filed4 = 1;
  func2 = function(){}
}

下面我们借助babel来探讨es6类和继续的完成道理。

1.类的完成

转换前：

class Parent {
  constructor(a){
    this.filed1 = a;
  }
  filed2 = 2;
  func1 = function(){}
}

转换后：

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

var Parent = function Parent(a) {
  _classCallCheck(this, Parent);

  this.filed2 = 2;

  this.func1 = function () { };

  this.filed1 = a;
};

可见class的底层依然是组织函数：

1.挪用_classCallCheck要领推断当前函数挪用前是不是有new关键字。

组织函数实行前有new关键字，会在组织函数内部建立一个空对象，将组织函数的proptype指向这个空对象的_proto_,并将this指向这个空对象。如上，_classCallCheck中：this instanceof Parent 返回true。

若组织函数前面没有new则组织函数的proptype不会不出现在this的原型链上，返回false。

2.将class内部的变量和函数赋给this。

3.实行constuctor内部的逻辑。

4.return this (组织函数默许在末了我们做了)。

2.继续完成

转换前：

class Child extends Parent {
    constructor(a,b) {
      super(a);
      this.filed3 = b;
    }
  
  filed4 = 1;
  func2 = function(){}
}

转换后：

我们先看Child内部的完成，再看内部挪用的函数是怎样完成的：

var Child = function (_Parent) {
  _inherits(Child, _Parent);

  function Child(a, b) {
    _classCallCheck(this, Child);

    var _this = _possibleConstructorReturn(this, (Child.__proto__ || Object.getPrototypeOf(Child)).call(this, a));

    _this.filed4 = 1;

    _this.func2 = function () {};

    _this.filed3 = b;
    return _this;
  }

  return Child;
}(Parent);

1.挪用_inherits函数继续父类的proptype。

_inherits内部完成：

function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: { value: subClass, enumerable: false, writable: true, configurable: true }
  });
  if (superClass)
    Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
}

(1) 校验父组织函数。

(2) 典范的寄生继续：用父类组织函数的proptype建立一个空对象，并将这个对象指向子类组织函数的proptype。

(3) 将父组织函数指向子组织函数的_proto_（这步是做什么的不太明白，觉得没什么意义。）

2.用一个闭包保留父类援用，在闭包内部做子类组织逻辑。

3.new搜检。

4.用当前this挪用父类组织函数。

var _this = _possibleConstructorReturn(this, (Child.__proto__ || Object.getPrototypeOf(Child)).call(this, a));

这里的Child.__proto__ || Object.getPrototypeOf(Child)实际上是父组织函数(_inherits末了的操纵)，然后经由过程call将其挪用方改成当前this，并通报参数。（这里觉得能够直接用参数传过来的Parent）

function _possibleConstructorReturn(self, call) {
  if (!self) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }
  return call && (typeof call === "object" || typeof call === "function") ? call : self;
}

校验this是不是被初始化，super是不是挪用，并返回父类已赋值完的this。

5.将行子类class内部的变量和函数赋给this。

6.实行子类constuctor内部的逻辑。

可见，es6实际上是为我们供应了一个“组合寄生继续”的简朴写法。

3. super

super代表父类组织函数。

super.fun1() 等同于 Parent.fun1() 或 Parent.prototype.fun1()。

super() 等同于Parent.prototype.construtor()

当我们没有写子类组织函数时：

var Child = function (_Parent) {
  _inherits(Child, _Parent);

  function Child() {
    _classCallCheck(this, Child);

    return _possibleConstructorReturn(this, (Child.__proto__ || Object.getPrototypeOf(Child)).apply(this, arguments));
  }

  return Child;
}(Parent);

可见默许的组织函数中会主动挪用父类组织函数，并默许把当前constructor通报的参数传给了父类。

所以当我们声清楚明了constructor后必需主动挪用super(),不然没法挪用父组织函数，没法完成继续。

典范的例子就是Reatc的Component中，我们声明constructor后必需挪用super(props)，由于父类要在组织函数中对props做一些初始化操纵。