国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

JS面向對象的程序設計之繼承的實現 - 原型鏈的注意點

pf_miles / 1543人閱讀

摘要:第一種方式是使用操作符,只要檢測的實例對象中的原型鏈包含出現過的構造函數,結果就會返回。而這也正是組合使用原型模式和構造函數模式的原因。在構造函數模式中定義屬性,在原型模式中定義共享的方法。

前言:最近在細讀Javascript高級程序設計,對于我而言,中文版,書中很多地方翻譯的差強人意,所以用自己所理解的,嘗試解讀下。如有紕漏或錯誤,會非常感謝您的指出。文中絕大部分內容引用自《JavaScript高級程序設計第三版》。

接上篇

JS面向對象的程序設計之繼承的實現 - 原型鏈

1. 別忘記默認的原型

事實上,前面例子中展示的原型鏈還少一環。

我們都知道, 所有引用類型默認都繼承了Object,而這個繼承也是通過原型鏈實現的。

所有函數的默認原型是Object的實例。因為函數的原型對象也是對象嘛! 對象當然是Object的實例咯!

因此函數的原型都會包含一個內部指針(__proto__), 指向Object.prototype。

這也是所有自定義類型都會繼承toString()、valueOf()等默認方法的根本原因。

所以,上篇例子中展示的原型的原型鏈中還應該包括另外一個繼承層次。

以下代碼展示了這個完整的原型鏈。

//完整原型鏈的偽代碼

function Object() {
}

Object.prototype = {
    constructor: f Object(),
    hasOwnProperty: f hasOwnProperty(),
    isPrototypeOf: f isPrototypeOf(),
    propertyIsEnumerable: f propertyIsEnumerable(),
    toLocaleString: f toLocaleString(),
    toString: f toString(),
    valueOf: f valueOf()
}

//SuperType 父類型
function SuperType(){
    this.property = true;
}

SuperType.prototype.getSuperProperty = function() {
    console.log(this.property);
    return this.property;
}

/*

SuperType.prototype = {
    constructor: f SuperType(),
    getSuperProperty: function() {
    console.log(this.property);
    return this.property;
    }, 
    __proto__ : {
        constructor: f Object(),
        hasOwnProperty: f hasOwnProperty(),
        isPrototypeOf: f isPrototypeOf(),
        propertyIsEnumerable: f propertyIsEnumerable(),
        toLocaleString: f toLocaleString(),
        toString: f toString(),
        valueOf: f valueOf()
    }
}
*/


//SubType 子類型
function SubType() {
    this.subproperty = false;
}


//子類型 繼承 父類型
SubType.prototype = new SuperType();


//實際上子類型的原型是這樣的。
/*SubType.prototype = {
    property: true,
    __proto__:  {
        constructor : SuperType,
        getSuperProperty:function() {
            console.log(this.property);
            return this.property;
        }
    }
}
*/

SubType.prototype.getSubProperty = function(){
    console.log(this.subproperty);
    return this.subproperty;
}


//那么現在子類型的原型對象是這樣的
/*SubType.prototype = {
    property: true,
    getSubProperty: function()  {
    console.log(this.subproperty);
    return this.subproperty;
    },
    __proto__:  {
        constructor : SuperType,
        getSuperProperty:function() {
            console.log(this.property);
            return this.property;
        }
    }
}
*/

var subInstanceObject = new SubType();
console.log(subInstanceObject.getSuperProperty()); // true

一句話,SubType(子類型)繼承了SuperType(父類型),

而SuperType(父類型)繼承了Object(祖先)。

當調用subInstanceObject.toString()時,實際上調用的是在保存在Object.prototype中的那個方法。

2. 確定原型和實例對象關系

可以通過兩種方式來確定原型和實例之間的關系。

第一種方式是使用instanceof操作符,只要檢測的實例對象中的原型鏈包含出現過的構造函數,結果就會返回true。
因為,這說明他們都參與了,實例對象的創建。

console.log(subInstanceObject instanceof Object); // true
console.log(subInstanceObject instanceof SuperType); // true
console.log(subInstanceObject instanceof SubType); // true

由于原型鏈的關系, 我們可以說subIntanceObject是Object、SuperType或SubType中任何一個類型的實例。

第二種方式是使用isPrototypeOf()方法。同樣,只要是原型鏈中出現過的原型,都可以說該原型鏈所派生的實例對象的原型。

console.log(Object.prototype.isPrototypeOf(subInstanceObject)); //true
console.log(SuperType.prototype.isPrototypeOf(subIntanceObject)); // true
console.log(SubType.prototype.isPrototypeOf(subIntanceObject)); //true
3. 謹慎地定義方法

子類型有時候需要覆蓋父類型的某個方法,或者需要添加父類型中不存在的某個方法。

但不管怎么樣,給原型添加方法的代碼一定要放在替換原型的語句之后。

function SuperType() {
    this.property = true;
}

SuperType.prototype.getSuperValue = function() {
    return this.property;
}

function SubType() {
    this.subproperty = false;
}

//繼承了SuperType
SubType.prototype = new SuperType();

//給原型添加方法的代碼一定要放在替換原型的語句之后
//添加新方法
SubType.prototype.getSubValue = function() {
    return this.subproperty;
}

//重寫 超類型中 的 方法
SubType.prototype.getSuperValue = function() {
    return false;
}

var instance = new SubType();
console.log(instance.getSuperValue())

以上代碼中,第一個方法getSubValue()被添加到了SubType中。
第二個方法getSuperValue()是原型中已經存在的一個方法。
重寫這個方法將會子類的原型會查找到屬于自己的getSuperValue()方法。
當通過SuperType的實例對象調用getSuperValue()時, 還會繼續調用原來的那個方法。

再次強調,必須在用SuperType的實例對象替換原型之后,再定義兩個方法。

還有一點需要提醒,即在通過原型鏈實現繼承時,不能使用對象字面量創建原型方法。這樣會重寫原型鏈的。

function SuperType(){
    this.property = true;
}

SuperType.prototype.getSuperValue = function(){
    return this.property;
}

function SubType(){
    this.subproperty = false;
}

//繼承SuperType
SubType.prototype = new SuperType();

/* 
現在的原型
SubType.prototype = {

    property: true,
    __proto__: {
        constructor: SuperType,
        getSuperValue: function() {
            return this.property;
        }
    }
}
*/

//使用對象字面量語法會改寫原型,導致上一行代碼無效
// SubType.prototype = new Object();
SubType.prototype = {

    getSubValue: function() {
        return this.subproperty;
    },

    someOtherMethod: function () {
        return false;
    }

    /*,
    __proto__ : {
        constructor: fn Object(),
        .......
    }
    */

}

var instance =  new SubType();
console.log(instance.getSuperValue()); // error: instance.getSuperValue is not a function

以上代碼展示了剛剛把SuperType的實例對象賦值給原型,緊接著又將原型替換成一個對象字面量而導致的問題。

因為SubType的原型其實保存的是一個Object的實例,而非SuperType的實例對象,因此這條鏈子斷了。

4. 原型鏈的問題

原型鏈雖然很強大,可以用它來實現繼承,但是總有缺點,世界上不存在萬全法。

最主要的問題來自包含引用類型值的原型。

包含引用類型值的原型屬性會被所有實例對象共享。

而這也正是組合使用原型模式和構造函數模式的原因。
在構造函數模式中定義屬性,在原型模式中定義共享的方法。

在通過原型來實現原型繼承時,原型實際上會變成另一個類型的實例對象。

原先的實例對象屬性,也就變成了現在的原型屬性了。

function SuperType() {
    this.colors = ["red", "green", "blue"];
}

function SubType() {
}

// 子類型繼承父類型
SubType.prototype = new SuperType();

/*
SubType.prototype = {
    colors: ["red", "green", "blue"],
    __proto__: {
        constructor: fn SuperType(),
        .....
    }
}
*/

var instance1 = new SubType();

instance1.colors.push("black");

console.log(instance1.colors); // ["red", "green", "blue", "black"]

var instance2 = new SubType();

console.log(instance2.colors); // ["red", "green", "blue", "black"]

原型鏈的第二個問題在于, 沒有辦法在不影響所有實例對象的情況下,給父類型的構造函數傳遞參數。

由于上述兩個問題的存在,事件中很少會多帶帶使用原型鏈。

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/98507.html

相關文章

  • JS面向對象程序設計繼承實現 - 原型

    摘要:簡單回顧一下構造函數原型和實例對象之間的關系每個構造函數都有一個原型對象。找到生成構造函數的原型對象的構造函數,搜索其原型對象,找到了。 JS面向對象的程序設計之繼承的實現 - 原型鏈 前言:最近在細讀Javascript高級程序設計,對于我而言,中文版,書中很多地方翻譯的差強人意,所以用自己所理解的,嘗試解讀下。如有紕漏或錯誤,會非常感謝您的指出。文中絕大部分內容引用自《JavaS...

    zhaochunqi 評論0 收藏0
  • 如何理解JavaScript原型原型鏈?

    摘要:之前有朋友問怎么去理解原型和原型鏈的問題。理解原型鏈的小技巧將箭頭視作泛化子類到父類關系那么圖中所有的虛線將構成一個繼承層級,而實線表示屬性引用。原型鏈是實現繼承的重要方式,原型鏈的形成是真正是靠而非。 之前有朋友問怎么去理解原型和原型鏈的問題。這個問題,在面試中,很多同學經常都會遇到。這里給大家講講,方便大家記憶。 JavaScript的特點JavaScript是一門直譯式腳本...

    xuexiangjys 評論0 收藏0
  • 如何理解JavaScript原型原型鏈?

    摘要:之前有朋友問怎么去理解原型和原型鏈的問題。理解原型鏈的小技巧將箭頭視作泛化子類到父類關系那么圖中所有的虛線將構成一個繼承層級,而實線表示屬性引用。原型鏈是實現繼承的重要方式,原型鏈的形成是真正是靠而非。 之前有朋友問怎么去理解原型和原型鏈的問題。這個問題,在面試中,很多同學經常都會遇到。這里給大家講講,方便大家記憶。 JavaScript的特點JavaScript是一門直譯式腳本...

    adie 評論0 收藏0
  • SegmentFault 技術周刊 Vol.32 - 七夕將至,你對象”還好嗎?

    摘要:很多情況下,通常一個人類,即創建了一個具體的對象。對象就是數據,對象本身不包含方法。類是相似對象的描述,稱為類的定義,是該類對象的藍圖或原型。在中,對象通過對類的實體化形成的對象。一類的對象抽取出來。注意中,對象一定是通過類的實例化來的。 showImg(https://segmentfault.com/img/bVTJ3H?w=900&h=385); 馬上就要到七夕了,離年底老媽老爸...

    Lyux 評論0 收藏0
  • SegmentFault 技術周刊 Vol.32 - 七夕將至,你對象”還好嗎?

    摘要:很多情況下,通常一個人類,即創建了一個具體的對象。對象就是數據,對象本身不包含方法。類是相似對象的描述,稱為類的定義,是該類對象的藍圖或原型。在中,對象通過對類的實體化形成的對象。一類的對象抽取出來。注意中,對象一定是通過類的實例化來的。 showImg(https://segmentfault.com/img/bVTJ3H?w=900&h=385); 馬上就要到七夕了,離年底老媽老爸...

    AaronYuan 評論0 收藏0

發表評論

0條評論

pf_miles

|高級講師

TA的文章

閱讀更多
最新活動
閱讀需要支付1元查看
<