function SuperType(){
  this.property = true;
}
SuperType.prototype.getSuperValue = function(){
  return this.property;
};
function SubType(){
  this.subproperty = false;
}
SubType.prototype = new SuperType();    // 敲黑板！這是重點(diǎn)：繼承了 SuperType
SubType.prototype.getSubValue = function (){
  return this.subproperty;
};
var instance = new SubType();
alert(instance.getSuperValue());    // true

alert(Object.prototype.isPrototypeOf(instance));    //true
alert(SuperType.prototype.isPrototypeOf(instance));   //true
alert(SubType.prototype.isPrototypeOf(instance));    //true

function SuperType(){
  this.colors = [ "red", "blue", "green"];
}
function SubType(){
  SuperType.call(this);    // 敲黑板！注意了這里繼承了 SuperType
}
var instance1 = new SubType();
instance1.colors.push("black");
alert(instance1.colors);    // "red,blue,green,black"
var instance2 = new SubType();
alert(instance2.colors);    // "red,blue,green"

function SuperType(name){
  this.name = name;
  this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function(){
  alert(this.name);
};
function SubType(name, age){
  SuperType.call(this, name);   // 繼承屬性
  this.age = age;         // 先繼承，后定義新的自定義屬性
}
SubType.prototype = new SuperType();    // 繼承方法
Object.defineProperty( SubType.prototype, "constructor", {   // 先繼承，后定義新的自定義屬性
  enumerable: false,   // 申明該數(shù)據(jù)屬性——constructor不可枚舉
  value: SubType
});
SubType.prototype.sayAge = function(){   // 先繼承，后定義新的自定義方法
  alert(this.age);
};
var instance1 = new SubType("Nicholas", 29);
instance1.colors.push("black");
alert(instance1.colors);    // "red, blue, green, black"
instance1.sayName();      // "Nicholas"
instance1.sayAge();       // 29
var instance2 = new SubType("Greg", 27);
alert(instance2.colors);    // "red, blue, green"
instance2.sayName();      // "Greg";
instance2.sayAge();       // 27

function object(o){
  function F(){}
  F.prototype = o;
  return new F();
}

var person = {
  name: "Nicholas",
  friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = Object.create(person, {
  name: {
    value: "Greg"
  }
});
anotherPerson.friends.push("Rob");
alert(anotherPerson.name);   //"Greg"
var yetAnotherPerson = Object.create(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.friends.push("Barbie");
alert(person.friends);   //"Shelby,Court,Van,Rob,Barbie"

function object(o){
  function F(){}
  F.prototype = o;
  return new F();
}
function createAnother(original){
  var clone = object(original);  // 通過(guò)調(diào)用函數(shù)創(chuàng)建一個(gè)新對(duì)象
  clone.sayHi = function(){    // 以某種方式來(lái)增強(qiáng)這個(gè)對(duì)象
    alert("hi");
  };
  return clone;          // 返回這個(gè)對(duì)象
}

function object(o){
  function F(){}
  F.prototype = o;
  return new F();
}
function inheritPrototype(subType, superType){
  var prototype = object(superType.prototype);    //創(chuàng)建對(duì)象
  prototype.constructor = subType;          //增強(qiáng)對(duì)象
  subType.prototype = prototype;           //指定對(duì)象
}
function SuperType(name){
  this.name = name;
  this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function(){
  alert(this.name);
};
function SubType(name, age){
  SuperType.call(this, name);     // 繼承屬性
  this.age = age;
}
inheritPrototype(SubType, SuperType);    // 繼承原型方法
SubType.prototype.sayAge = function(){
  alert(this.age);
};

class Child extends Parent{
  name ='qinliang';
  sex = "male";
  static hobby = "pingpong";   //static variable
  constructor(location){
    super(location);
  }
  sayHello (name){
    super.sayHello(name);    //super調(diào)用父類(lèi)方法
  }
}

function _inherits(subClass, superClass) {
  //SuperClass必須是一個(gè)函數(shù)，同時(shí)非null
  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,   //原型上的方法、屬性全部被繼承過(guò)來(lái)了
    {
      constructor: {   // 并且定義了新屬性，這里是重寫(xiě)了constructor屬性
        value: subClass,
        enumerable: false,   // 并實(shí)現(xiàn)了該屬性的不可枚舉
        writable: true,
        configurable: true
      }
    }
  );
  if (superClass)   // 實(shí)現(xiàn)類(lèi)中靜態(tài)變量的繼承
    Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
}

"use strict";
var _createClass = function () {    // 利用原型模式創(chuàng)建自定義類(lèi)型
  function defineProperties(target, props) {   // 對(duì)屬性進(jìn)行數(shù)據(jù)特性設(shè)置
    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);
    }
  }
  return function (Constructor, protoProps, staticProps) {
    // 設(shè)置Constructor的原型屬性到prototype中
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    // 設(shè)置Constructor的static類(lèi)型屬性
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
}();
var _get = function get(object, property, receiver) {  // 調(diào)用子類(lèi)的方法之前會(huì)先調(diào)用父類(lèi)的方法
  // 默認(rèn)從Function.prototype中獲取方法
  if (object === null) object = Function.prototype;
  // 獲取父類(lèi)原型鏈中的指定方法
  var desc = Object.getOwnPropertyDescriptor(object, property);
  if (desc === undefined) {
    var parent = Object.getPrototypeOf(object);   // 繼續(xù)往上獲取父類(lèi)原型
    if (parent === null) {
      return undefined;
    } else {    // 繼續(xù)獲取父類(lèi)原型中指定的方法
      return get(parent, property, receiver);
    }
  } else if ("value" in desc) {
    return desc.value;   // 返回獲取到的值
  } else {
    var getter = desc.get;   // 獲取原型的getter方法
    if (getter === undefined) {
      return undefined;
    }
    return getter.call(receiver);    // 接著調(diào)用getter方法，并傳入this對(duì)象
  }
};
function _classCallCheck(instance, Constructor) {    // 保證了我們的實(shí)例對(duì)象是特定的類(lèi)型
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}
// 在子類(lèi)的構(gòu)造函數(shù)中調(diào)用父類(lèi)的構(gòu)造函數(shù)
function _possibleConstructorReturn(self, call) {    // 一參為子類(lèi)的this，二參為父類(lèi)的構(gòu)造函數(shù)
  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;
}
var Child = function (_Parent) {
  _inherits(Child, _Parent);
  function Child(location) {   // static variable
    _classCallCheck(this, Child);    // 檢測(cè)this指向問(wèn)題
    // 調(diào)用父類(lèi)的構(gòu)造函數(shù)，并傳入子類(lèi)調(diào)用時(shí)候的參數(shù)，生成父類(lèi)的this或者子類(lèi)自己的this
    var _this = _possibleConstructorReturn(this, (Child.__proto__ || Object.getPrototypeOf(Child)).call(this, location));
    _this.name = 'qinliang';
    _this.sex = "male";
    return _this;
  }
  _createClass(Child, [{   //更新Child類(lèi)型的原型
    key: "sayHello",
    value: function sayHello(name) {
      // super調(diào)用父類(lèi)方法，將調(diào)用子類(lèi)的super.sayHello時(shí)候傳入的參數(shù)傳到父類(lèi)中
      _get(Child.prototype.__proto__ || Object.getPrototypeOf(Child.prototype), "sayHello", this).call(this, name);
    }
  }]);
  return Child;
}(Parent);
Child.hobby = "pingpong";