理解 es6 中class构造以及继承的底层实现原理

理解 es6 中class构造以及继承的底层实现原理

原文链接：https://blog.csdn.net/qq_34149805/article/details/86105123

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类和继承的实现原理 

 2、类的实现

　　转换前：

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

　　转换后：

function _classCallCheck(instance, Constructor) {
　// instanceof 检测构造函数的 prototype 属性是否出现在某个实例对象的原型链上。
  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关键字，会在构造函数内部创建一个空对象，将构造函数的prototype指向这个空对象的__prpto__，并将this指向这个空对象。如上，_classCallCheck中：this instanceof Parent，返回true。

　　　　若构造函数前面没有new则构造函数的prototype不会出现在this的原型链上，返回false

　　2）将class内部的变量函数赋值给this

　　3）执行constructor内部的逻辑

　　4）return this（构造函数默认在最后帮我们做了这一步）

3、继承实现

　　转换前：

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);

　　① 调用_inherits函数继承父类的prototype

　　_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. 典型的寄生继承：用父类构造函数的prototype创建一个空对象，并将这个对象指向子类构造函数的prototype

　　3. 将父构造函数指向子构造函数的_proto_

　　② 用一个闭包保存父类引用，在闭包内部做子类构造逻辑

　　③ new 检查

　　④ 用当前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。

　　⑤ 执行子类class内部的变量和函数赋给this

　　⑥ 执行子类constructor内部逻辑

　　可见，ES6实际上是提供了一个"组合寄生继承"的简单写法

4、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做一些初始化操作。