ES5 / ES6 의 계승

function Parent() {}

function Child() {
    //         
    Parent.call(this) //           this   
}

//         
Child.prototype = Object.create(Parent.prototype)

//         constructor   
Child.prototype.constructor = Child 

       ，                   __proto__

Object.create(null) //             
             

js                  
function createObject(P) {
    var F = function() {}
    F.prototype = P.prototype
    return new F()
}

      ：
     prototype        constructor   ，        
     ，          constructor   ，     prototype   constructor   

           ，    
var c = new C()
c.constructor === Child // false
Child.prototype.constructor === Child // false

c.constructor === Parent // true
Child.prototype.constructor === Parent // true

            (c         Child   )，          

//    class extends    
class Parent {
    static sayAge() {
        return '18'
    }
      constructor(name) {
        this.name = 'name'
    }
}

class Child extends Parent {
    constructor(name, age) {
        /**
         *     constructor      super   ，          this   ，               
         *    super      this  ，new        
         * Uncaught ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor
         * 
         * ES5               this，             this    (Parent.call(this))
         * ES6                  ，   this   （      super   ），            this
        */
        super(name, age)
          this.age = age
    }
}
//    ：es6                    ， ES5     
//    extends   ，Child.__proto__ ==== Parent // true
// Parent.__proto__    f() { [native code] }
// Parent.__proto__.__proto__ === Object.prototype

//      ，              
"use strict";

//           super   
function _possibleConstructorReturn(self, call) {
  if (call && (_typeof(call) === "object" || typeof call === "function")) {
    return call;
  }
  return _assertThisInitialized(self);
}

function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return self;
}

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

//       
function _inherits(subClass, superClass) {
  // ...
  //   es5       
  subClass.prototype = Object.create(superClass.prototype, {
    constructor: { 
        value: subClass, //    constructor   
        writable: true, 
        configurable: true 
    }
  });
  //                 ：Child.__proto__ = Parent
  //    (         )      prototype = Parent，                 
  if (superClass) _setPrototypeOf(subClass, superClass);
}

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

// ...             

var Parent =
  /*#__PURE__*/
  (function() {
    _createClass(Parent, null, [
      {
        key: "sayAge",
        value: function sayAge() {
          return "18";
        }
      }
    ]);

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

      this.name = "name";
    }

    return Parent;
  })();

var Child =
  /*#__PURE__*/
  (function(_Parent) {
    _inherits(Child, _Parent);

    function Child(name, age) {
      var _this;

      _classCallCheck(this, Child);
      
      //            super    ，      super       this
      _this = _possibleConstructorReturn(this, _getPrototypeOf(Child).call(this, name, age));

      /***
        *          super         
        * _this.age = age;
        * return _possibleConstructorReturn(_this);
        *        super       this，         
        *
        *         _this.age = age
        *       _assertThisInitialized   ，    ，     super   
      */

      _this.age = age;
      return _this;
    }

    return Child;
  })(Parent);

var c = new Child();

//      babel  ，         ，   super，      babel           
//       ： Uncaught ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor

var obj = {}
obj.__proto__ = Child.prototype
F.call(obj)

// 1.        
// 2.         __proto__             prototype      ==>         
// 3.        this        obj（  ），               ===>