javascript中的類式繼承

//輔助函數，讓你能夠將新函數綁定到對象的prototype上
//爲Function.prototype增長一個公有方法。全部由類的擴充的函數均可以使用它,
//它返回this，當我寫一個不須要返回值的方法時，我一般讓它返回this，這顧慮到了串聯樣式
Function.prototype.method = function (name, func) {
    this.prototype[name] = func;
    return this;
};

//inherits方法，它的做用是讓一個類從另外一個上繼承
//這一函數能夠提供簡單的單對象繼承，他的代碼主要圍繞在任意對象方法中調用this.uber('methodName')爲中心，並再讓
//這個uber方法去執行他要覆蓋的父對象的方法
//容許從其餘對象繼承函數，同時仍然能夠調用屬於父對象的那些函數
Function.method("inherits", function (parent) {
//記錄目前所在父層次的級數
 var d = {}, 
//繼承父對象的方法
p = (this.prototype = new parent());
//建立一個新的名爲'uber'的"特權函數"，調用它時會執行全部在繼承時被重寫的函數
 this.method("uber", function uber(name) {
        if (!(name in d)) {
            d[name] = 0;
        }   
//f爲要執行的函數，r爲函數的返回值，v爲父對象的prototype     
        var f, r, t = d[name], v = parent.prototype;
//若是uber被調用的時候，會進入到這一步
         if (t) {
            while (t) {
//上溯到必要的d[name],以找到原始的prototype
                v = v.constructor.prototype;
                t -= 1;
            }
//從該prototype中獲取函數
 f = v[name];
        } 
//不然是'uber'的第一次調用       
  else {
//從prototype得到要執行的函數           
 f = p[name];
//若是此函數屬於當前的prototype   
 if (f == this[name]) {
//則改成調用父對象的prototype
 f = v[name];
            }
        }
//記錄咱們在繼承堆棧中所在位置的級數
 d[name] += 1;
//使用除第一個之外的全部的arguments 並調用此函數，由於第一個參數是執行的函數名
 r = f.apply(this, Array.prototype.slice.apply(arguments, [1]));
//恢復繼承堆棧
 d[name] -= 1;
//返回執行過的函數的返回值
 return r;
    });
    return this;
});

//swiss方法自始自終循環arguments參數，對於每個名稱，它都複製出一個成員從父類的原型上到新類的原型上。
//只繼承父對象特定函數的函數，而非使用new parent()，繼承全部函數
Function.method("swiss", function (parent) {
    for (var i = 1; i < arguments.length; i += 1) {
        var name = arguments[i];
        this.prototype[name] = parent.prototype[name];
    }
    return this;
});

方法的使用
function Parenizor(value) {

}
Parenizor.method("toal", function () {
    return("haode");
});
function mParenizor(value) {

}
mParenizor.inherits(Parenizor);
mParenizor.method("toal", function () {
       var a=3;
       return this.uber("toal");
 });	
    
function fParenizor(value) {
   

}
fParenizor.inherits(mParenizor);
 fParenizor.method("toal", function (name) {
        var a=2;
       return this.uber("toal","haerbin");
 });	

 function hParenizor(value) {
   
}
hParenizor.inherits(fParenizor);
hParenizor.method("toal", function () {
       var a=1;
       return this.uber("toal","lilei");
 });	

var myZParenizor = new hParenizor("laoli");
     var myString = myZParenizor.toal();

new子對象的實例，而後調用toal方法，toal方法執行到return this.uber("toal","lilei")這句的時候，會調用inherits函數
的uber方法，因爲此方法第一次執行，因此d[toal]=0，而後進入f=p[toal],因爲當前對象有toal方法，向下執行，將f置爲
父對象的toal方法，計數器d[toal]加1，而後執行r = f.apply(this, Array.prototype.slice.apply(arguments, [1]));
此方法將參數傳遞給f函數，並將指針改成this，來執行父對象的toal方法，而後父對象的toal方法被執行，
fParenizor.method("toal", function (name) {//父對象的toal方法被執行
        var a=2;
       return this.uber("toal","haerbin");
 });	
當執行到 return this.uber("toal","haerbin") 因爲第二次執行此方法，因此d[toal]爲1，而後進入while循環，
 經過v = v.constructor.prototype將直接找到v的原始的prototype，執行原始prototype上的toal方法，
Parenizor.method("toal", function () {
    return("haode");
});
而後將返回值賦給r，而後將d[toal]減1（因爲已經找到原始的toal方法，d[toal]值應爲1，因此進行自減）.
這是我對類式繼承的理解，不知道有沒有高手幫我看下，給修改或補充下唄