共计 3150 个字符，预计需要花费 8 分钟才能阅读完成。
在阅读文章之前，您至少需要对 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 做一些初始化操作。
