在JavaScript類中調用父方法，但可以訪問對象實例內的原型方法嗎？

Question

是否可以在JavaScript類中調用父方法，但是仍然可以訪問父類和子類中的原型方法。下面是代碼示例：

var Base = function() { 

    this.baseMethod = function(){ 
    return 'baseMethod'; 
    }; 

    this.baseInitMethod = function() { 
    return 'baseInitMethod'; 
    } 
} 


Base.prototype.basePrototypeMethod = function() { 
    return "basePrototypeMethod"; 
}; 


var Specific = function() { 

    Base.call(this); 

    this.baseInitMethod = function() { 
    // call baseInitMethod from Base class 
    } 

    this.specificMethod = function(){ 
    return 'specificMethod'; 
    } 

    this.specificInitMethod = function() { 

    return this.basePrototypeMethod(); 
    } 
} 


Specific.prototype.specificPrototypeMethod = function() { 
    return 'specificPrototypeMethod' + '-' + this.baseInitMethod(); 
} 


for(var p in Base.prototype) { 
    Specific.prototype[p] = Base.prototype[p] 
} 


var s = new Specific(); 


console.log(s.baseMethod()); 

console.log(s.baseInitMethod()); 

console.log(s.basePrototypeMethod()); 

console.log(s.specificMethod()); 

console.log(s.specificInitMethod()); 

console.log(s.specificPrototypeMethod()); 

我想從baseInitMethod方法調用baseInitMethod在基類特殊類中，但讓所有的功能從上面仍然有效調用。那可能嗎？

Answer 1

你Specific.prototype對象應從Base.prototype對象繼承。目前你在複製其所有屬性的對象與此代碼：

for(var p in Base.prototype) { 
    Specific.prototype[p] = Base.prototype[p] 
} 

但實際上，應該使用Object.create建立一個真正的原型鏈：

Specific.prototype = Object.create(Base.prototype); 

Specific.prototype.specificPrototypeMethod = function() { 
    return 'specificPrototypeMethod' + '-' + this.baseInitMethod(); 
} 

---

我想調用baseInitMethod中的baseInitMethod hod inside具體分類

是的。在你Specific構造函數，你首先需要獲得Base的baseInitMethod實例方法，您覆蓋實例的屬性之前：

function Specific() { 
    Base.call(this); 

    var parentInitMethod = this.baseInitMethod; 
    this.baseInitMethod = function() { 
     // call baseInitMethod from Base class: 
     parentInitMethod.call(this /*, arguments…*/); 
    } 

    … 
} 

，使所有功能從上面仍然有效調用。

我不確定你確切的意思。 specificPrototypeMethod將始終調用當前實例的baseInitMethod，這將覆蓋Specific而不是Base中定義的原始實例。

Answer 2

以下是你需要做的：

var Base = function() { 
}; 
Base.prototype.baseMethod = function() { 
    return 'baseMethod'; 
}; 
Base.prototype.baseInitMethod = function() { 
    return 'baseInitMethod'; 
}; 
Base.prototype.basePrototypeMethod = function() { 
    return "basePrototypeMethod"; 
}; 


var Specific = function() { 
    Base.apply(this, arguments); 
}; 
Specific.prototype.baseInitMethod = function() { 
    Base.prototype.baseInitMethod.apply(this,arguments); 
}; 

Specific.prototype.specificMethod = function() { 
    return 'specificMethod'; 
}; 

Specific.prototype.specificInitMethod = function() { 
    var basePrototypeMethodCallResult = Base.prototype.basePrototypeMethod.apply(this,arguments); 

}; 

Answer 3

你覆蓋的Base內Specific的baseInitMethod，與Specific的定義，那麼，爲什麼你會永遠想調用基版本？如果你只是刪除功能的覆蓋，你應該調用基定義：

var Base = function() { 

    this.baseMethod = function(){ 
    return 'baseMethod'; 
    }; 

    this.baseInitMethod = function() { 
    return 'baseInitMethod'; 
    } 
} 


Base.prototype.basePrototypeMethod = function() { 
    return "basePrototypeMethod"; 
}; 


var Specific = function() { 

    Base.call(this); 

    this.baseInitMethod(); // calls the Base definition only 

    this.specificMethod = function(){ 
    return 'specificMethod'; 
    } 

    this.specificInitMethod = function() { 

    return this.basePrototypeMethod(); 
    } 
} 

Answer 4

有人可能會爭辯說：「爲什麼總是試圖模仿'古典'的行爲，並與call和apply大驚小怪，而不是接受原型委託模式呢？」

這裏是我的代碼：

var Base = { 

    baseVariable1: "baseValue1", 

    baseVariable2: "baseValue2", 

    baseMethod: function() { 
     return 'baseMethod'; 
    }, 

    baseInitMethod: function() { 
     return 'baseInitMethod'; 
    } 
} 

var Specific = Object.create(Base); 

Specific.variable1 = "value1"; 

Specific.variable2 = "value2"; 

Specific.specificInitMethod = function() { 
    return 'specificInitMethod' + '-' + this.baseInitMethod(); 
} 

Specific.specificMethod = function() { 
    return 'specificMethod' + '-' + this.baseInitMethod(); 
} 

var s = Object.create(Specific); 

console.log(s.baseInitMethod()); 

console.log(s.baseVariable1); 

console.log(s.baseVariable2); 

console.log(s.variable1); 

console.log(s.variable2); 

console.log(s.baseMethod()); 

console.log(s.specificInitMethod()); 

console.log(s.specificMethod());