Babel编译：类继承

 

编译前

 

// 父类
class Fruit {
    static nutrition = "vitamin"
    static plant() {
        console.log('种果树');
    }
    name;
    constructor(name) {
        this.name = name;
    }
    hello() {
        console.log(this.name);
    }
}

// 子类
class Mongo extends Fruit {
    constructor(name, level) {
        super(name);
        this.level = level;
    }
    eat() {
        console.log(super.name, this.name);
    }
}

 

编译后

 

"use strict";

// 获取类型
function _typeof(obj) {
    // 运行环境原生支持Symbol
    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
        _typeof = function _typeof(obj) {
            return typeof obj;
        };
    }
    // 模拟实现Symbol
    else {
        _typeof = function _typeof(obj) {
            return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
        };
    }
    return _typeof(obj);
}

/**
 * 可能调用父类的构造函数，返回了创建的事物
 * @param {Object} self - 上下文
 * @param {Object} call - 调用父构造函数，创建的事务（对象/函数）
 */
function _possibleConstructorReturn(self, call) {
    // 语法规则：构造函数通过new运算符调用时，只能返回对象/函数
    if (call && (_typeof(call) === "object" || typeof call === "function")) {
        return call;
    }
    return _assertThisInitialized(self);
}

// 断言上下文已被初始化
function _assertThisInitialized(self) {
    // 没有调用super初始化上下文，抛异常
    if (self === void 0) {
        throw new ReferenceError(
            "this hasn't been initialised - super() hasn't been called"
        );
    }
    return self;
}

// 读取属性
function _get(target, property, receiver) {
    // 支持Reflect
    if (typeof Reflect !== "undefined" && Reflect.get) {
        _get = Reflect.get;
    } 
    // 模拟Relect
    else {
        _get = function _get(target, property, receiver) {
            var base = _superPropBase(target, property);
            if (!base) return;
            var desc = Object.getOwnPropertyDescriptor(base, property);
            if (desc.get) {
                return desc.get.call(receiver);
            }
            return desc.value;
        };
    }
    return _get(target, property, receiver || target);
}

// 沿着原型链向上查找，直到找到最早拥有该属性的原型对象（即不是通过继承获得该属性）
function _superPropBase(object, property) {
    while (!Object.prototype.hasOwnProperty.call(object, property)) {
        object = _getPrototypeOf(object);
        if (object === null) break;
    }
    return object;
}

// 读取__proto__
function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf
        ? Object.getPrototypeOf
        : function _getPrototypeOf(o) {
            return o.__proto__ || Object.getPrototypeOf(o);
        };
    return _getPrototypeOf(o);
}

// 继承
function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
    }
    // 继承成员方法：子构造函数的prototype，继承父构造函数的prototype
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: { value: subClass, writable: true, configurable: true }
    });
    // 继承静态属性、静态方法：子构造函数的__proto__，是父构造函数
    if (superClass) _setPrototypeOf(subClass, superClass);
}

// 设置__proto__
function _setPrototypeOf(o, p) {
    _setPrototypeOf =
        Object.setPrototypeOf ||
        function _setPrototypeOf(o, p) {
            o.__proto__ = p;
            return o;
        };
    return _setPrototypeOf(o, p);
}

function _instanceof(left, right) {
    if (
        right != null &&
        typeof Symbol !== "undefined" &&
        right[Symbol.hasInstance]
    ) {
        return !!right[Symbol.hasInstance](left);
    } else {
        return left instanceof right;
    }
}

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

function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}

function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
}

function _defineProperty(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}

var Fruit =
    /*#__PURE__*/
    (function () {
        _createClass(Fruit, null, [
            {
                key: "plant",
                value: function plant() {
                    console.log("种果树");
                }
            }
        ]);

        function Fruit(name) {
            _classCallCheck(this, Fruit);

            _defineProperty(this, "name", void 0);

            this.name = name;
        }

        _createClass(Fruit, [
            {
                key: "hello",
                value: function hello() {
                    console.log(this.name);
                }
            }
        ]);

        return Fruit;
    })();

_defineProperty(Fruit, "nutrition", "vitamin");

var Mongo =
    /*#__PURE__*/
    (function (_Fruit) {
        _inherits(Mongo, _Fruit);

        function Mongo(name, level) {
            var _this;

            _classCallCheck(this, Mongo);

            _this = _possibleConstructorReturn(
                this,
                _getPrototypeOf(Mongo).call(this, name)
            );
            _this.level = level;
            return _this;
        }

        _createClass(Mongo, [
            {
                key: "eat",
                value: function eat() {
                    console.log(
                        _get(_getPrototypeOf(Mongo.prototype), "name", this),
                        this.name
                    );
                }
            }
        ]);

        return Mongo;
    })(Fruit);