誤解我有關於javascript原型的繼承

Question

簡單的問題。

    function p()
    {
        function A()
        {
            this.random = "random";
        }
        A.prototype.newfunc = function(){ alert("5");}

        function B()
        {

        }

        B.prototype = new A();

        var bObj = new B();
    }

Q1：當我設置B的原型時，我不知道B的原型屬性如何更新/如果A的原型更新。 我的意思是，對我來說它只是繼承/復制所有這些屬性。 它不像是：

B.prototype = A.prototype

其中B和A是同一個。

Q2：在A被返回並初始化為B的原型對象之后，JS如何知道不包含該原型屬性？ 我的意思是，我們從來沒有出現過這種情況，因為JS解釋器只知道切斷A原型的屬性：

B.prototype = new A(); //any A object has an associated prototype object
    B.prototype.prototype;//after initialization we no longer have the separate prototype property of A

Answer 1

Q1：你自己說過 - 原型用於繼承。 因此B繼承了A的所有屬性。當您添加或更改A的成員時，B也會更改。 正如你所說，它們不一樣，但A是B的超類，如果超類中的任何內容發生變化，子類也會發生變化。 但是，您可以將成員添加到B.prototype並在不更改A的​​情況下更改其行為。

試試這個：

    function A()
    {
    }

    A.prototype.alertname = function () 
    {
        alert (this.name);
    };

    function B()
    {
    }

    B.prototype = new A();

    var bObj = new B();
    var aObj = new A();

    A.prototype.name = "A"; 
    aObj.alertname(); // output is "A";
    bObj.alertname(); // output is "A";

    B.prototype.name = "B";
    aObj.alertname(); // output is "A";
    bObj.alertname(); // output is "B";

Q2：再次，繼承與組成不同。 當您指定B.prototype時，您不只是將A類型的對象放在占位符中，而是更改B類型的所有對象的“藍圖”。因此，當您訪問所述藍圖時，您不會獲得對象類型A的藍圖，但是包含對類型A的藍圖的引用的類型B的藍圖。該藍圖將不具有類型原型的成員，因為原型不是任何類的“常規”成員。 將其添加到上面的代碼中：

function iterateMembers ( obj ) {
    var str = "";
    for (var member in obj) {
        str += member + ", "
    }
    alert (str);
}

iterateMembers (aObj);
iterateMembers (A.prototype); 

注意aObj和A.prototype都不包含成員“prototype”。 現在打電話

iterateMembers (A);
alert (typeof(A));

現在應該很明顯，prototype是類型函數的一個成員，並且由於函數不是由A或B繼承的（事實上，它不能被繼承），它們都不包含名為“prototype”的成員。

Answer 2

Q1：當我設置B的原型時，我不知道B的原型屬性如何更新/如果A的原型更新。 我的意思是，對我來說它只是繼承/復制所有這些屬性。

函數對象有一個prototype字段：

function A(name) { this.name = name }

print(A.prototype) // [object Object]

使用new A創建對象時，生成的對象包含constructor字段，該字段是對構造函數的引用：

var a = new A('Eric')

print(a.constructor == A) // True
print(a.constructor.prototype == A.prototype) // True

如果您嘗試索引a和外地是不確定的，JavaScript的將嘗試通過解決這a的原型（如a.constructor.prototype ）。 我們可以使用它來向所有A實例添加內容：

A.prototype.greet = function() { print('Hi, ' + this.name + '!') }

a.greet() // Hi, Eric!

此字段解析以遞歸方式工作。

function B(name) { this.name = name.toUpperCase() }
B.prototype = new A
b = new B("Eric")
b.greet() // Hi, ERIC!

最后一行中發生的事情是JavaScript在b找不到'greet'字段，所以它嘗試b的原型。 它也沒有找到，所以它嘗試* b的原型的原型，依此類推，直到它用完了原型。

譯員知道只是為了砍掉A原型的屬性：B.prototype.prototype

什么都沒有被砍掉，你只是看錯了。 你要：

B.prototype.constructor.prototype