function SuperType(){
  this.property = true;
}
SuperType.prototype.getSuperValue = function(){
  return this.property;
}
function SubType(){
  this.subproperty = false;
}
//繼承
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function(){
  return this.subproperty;
}
var instance = new SubType();

function SuperType(){
  this.colors = {"red","blue","green"}
}
function SubType(){
  SuperType.call(this);  
}
var instance = new SubType();

function SuperType(name){
  this.name = name;
  this.colors = {"red","blue","green"}
}
SuperType.prototype.sayName = function(){
  //code
}
function SubType(name,age){
  SuperType.call(this,name); 
  this.age = age;
}
SubType.prototype = new SuperType();
var instance = new SubType();

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

function inheritPrototype(subType,superType){
  var prototype = object(superType.prototype);
  prototype.constructor = subType;
  subType.prototype = prototype;
}
function SuperType(name){
  this.name = name;
  this.colors = {"red","blue","green"}
}
SuperType.prototype.sayName = function(){
  //code
}
function SubType(name,age){
  SuperType.call(this,name); 
  this.age = age;
}
inheritPrototype(SubType,SuperType);
var instance = new SubTYpe();

(function(){
  //initializing用于控制類的初始化，非常巧妙，請(qǐng)留意下文中使用技巧
  //fnTest返回一個(gè)正則比表達(dá)式，用于檢測函數(shù)中是否含有_super，這樣就可以按需重寫，提高效率。當(dāng)然瀏覽器如果不支持的話就返回一個(gè)通用正則表達(dá)式
  var initializing = false,fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
  //所有類的基類Class,這里的this一般是window對(duì)象
  this.Class = function(){};
  //對(duì)基類添加extend方法，用于從基類繼承
  Class.extend = function(prop){
    //保存當(dāng)前類的原型
    var _super = this.prototype;
    //創(chuàng)建當(dāng)前類的對(duì)象，用于賦值給子類的prototype，這里非常巧妙的使用父類實(shí)例作為子類的原型，而且避免了父類的初始化(通過閉包作用域的initializing控制)
    initializing = true;
    var prototype = new this();   
    initializing = false;
    //將參數(shù)prop中賦值到prototype中，這里的prop中一般是包括init函數(shù)和其他函數(shù)的對(duì)象
    for(var name in prop){
      //對(duì)應(yīng)重名函數(shù)，需要特殊處理，處理后可以在子函數(shù)中使用this._super()調(diào)用父類同名構(gòu)造函數(shù), 這里的fnTest很巧妙:只有子類中含有_super字樣時(shí)才處理從寫以提高效率
      prototype[name] = typeof prop[name] == "function" && typeof _super[name] == "function" && fnTest.test(prop[name])?
       (function(name,fn){
        return function(){
          //_super在這里是我們的關(guān)鍵字，需要暫時(shí)存儲(chǔ)一下
          var tmp = this._super; 
          //這里就可以通過this._super調(diào)用父類的構(gòu)造函數(shù)了       
          this._super = _super[name];
          //調(diào)用子類函數(shù) 
          fn.apply(this,arguments);
          //復(fù)原_super，如果tmp為空就不需要復(fù)原了
          tmp && (this._super = tmp);
        }
       })(name,prop[name]) : prop[name];
    }
    //當(dāng)new一個(gè)對(duì)象時(shí)，實(shí)際上是調(diào)用該類原型上的init方法,注意通過new調(diào)用時(shí)傳遞的參數(shù)必須和init函數(shù)的參數(shù)一一對(duì)應(yīng)
    function Class(){
      if(!initializing && this.init){
        this.init.apply(this,arguments);  
      }
    }    
    //給子類設(shè)置原型
    Class.prototype = prototype;
    //給子類設(shè)置構(gòu)造函數(shù)
    Class.prototype.constructor = Class;
    //設(shè)置子類的extend方法，使得子類也可以通過extend方法被繼承
    Class.extend = arguments.callee;
    return Class;
  }
})();

var Human = Class.extend({
 init: function(age,name){
  this.age = age;
  this.name = name;
 },
 say: function(){
  console.log("I am a human");
 }
});
var Man = Human.extend({
  init: function(age,name,height){
    this._super(age,name);
    this.height = height;
  }, 
  say: function(){
    this._super();
    console.log("I am a man"); 
  }
});
var man = new Man(21,'bob','191');
man.say();