国产精品白浆一区二小说,黄蓉的销魂夜1一6,99re6在线视频精品免费下载

基于這篇文章的一些名稱約定：

/*
 * 約定
 */
function Fun(){
    // 私有屬性
    var val = 1;        // 私有基本屬性
    var arr = [1];      // 私有引用屬性
    function fun(){}    // 私有函數（引用屬性）
 
    // 實例屬性
    this.val = 1;               // 實例基本屬性
    this.arr = [1];             // 實例引用屬性
    this.fun = function(){};    // 實例函數（引用屬性）
}
 
// 原型屬性
Fun.prototype.val = 1;              // 原型基本屬性
Fun.prototype.arr = [1];            // 原型引用屬性
Fun.prototype.fun = function(){};   // 原型函數（引用屬性）

上面的約定應該是比較合理的，如果難以理解，可以查看黯羽輕揚：JS學習筆記2_面向對象，了解更多的基本常識

js里常用的如下兩種繼承方式：

原型鏈繼承（對象間的繼承）
類式繼承（構造函數間的繼承）

由于js不像java那樣是真正面向對象的語言，js是基于對象的，它沒有類的概念。所以，要想實現繼承，可以用js的原型prototype機制或者用apply和call方法去實現

在面向對象的語言中，我們使用類來創建一個自定義對象。然而js中所有事物都是對象，那么用什么辦法來創建自定義對象呢？這就需要用到js的原型：

我們可以簡單的把prototype看做是一個模版，新創建的自定義對象都是這個模版（prototype）的一個拷貝（實際上不是拷貝而是鏈接，只不過這種鏈接是不可見，新實例化的對象內部有一個看不見的__Proto__指針，指向原型對象）。

js可以通過構造函數和原型的方式模擬實現類的功能。另外，js類式繼承的實現也是依靠原型鏈來實現的。

原型式繼承與類式繼承

類式繼承是在子類型構造函數的內部調用超類型的構造函數。
嚴格的類式繼承并不是很常見，一般都是組合著用：

function Super(){
    this.colors=["red","blue"];
}
 
function Sub(){
    Super.call(this);
}

原型式繼承是借助已有的對象創建新的對象，將子類的原型指向父類，就相當于加入了父類這條原型鏈

原型鏈繼承

為了讓子類繼承父類的屬性（也包括方法），首先需要定義一個構造函數。然后，將父類的新實例賦值給構造函數的原型。代碼如下：

<script>
    function Parent(){
        this.name = 'mike';
    }
 
    function Child(){
        this.age = 12;
    }
    Child.prototype = new Parent();//Child繼承Parent，通過原型，形成鏈條
 
    var test = new Child();
    alert(test.age);
    alert(test.name);//得到被繼承的屬性
    //繼續原型鏈繼承
    function Brother(){   //brother構造
        this.weight = 60;
    }
    Brother.prototype = new Child();//繼續原型鏈繼承
    var brother = new Brother();
    alert(brother.name);//繼承了Parent和Child,彈出mike
    alert(brother.age);//彈出12
</script>

以上原型鏈繼承還缺少一環，那就是Object，所有的構造函數都繼承自Object。而繼承Object是自動完成的，并不需要我們自己手動繼承，那么他們的從屬關系是怎樣的呢？

確定原型和實例的關系

可以通過兩種方式來確定原型和實例之間的關系。操作符instanceof和isPrototypeof()方法：

alert(brother instanceof Object)//true
alert(test instanceof Brother);//false,test 是brother的超類
alert(brother instanceof Child);//true
alert(brother instanceof Parent);//true

只要是原型鏈中出現過的原型，都可以說是該原型鏈派生的實例的原型，因此，isPrototypeof()方法也會返回true

在js中，被繼承的函數稱為超類型（父類，基類也行），繼承的函數稱為子類型（子類，派生類）。使用原型繼承主要由兩個問題：
一是字面量重寫原型會中斷關系，使用引用類型的原型，并且子類型還無法給超類型傳遞參數。

偽類解決引用共享和超類型無法傳參的問題，我們可以采用“借用構造函數”技術

d借用構造函數（類式繼承）

<script>
    function Parent(age){
        this.name = ['mike','jack','smith'];
        this.age = age;
    }
 
    function Child(age){
        Parent.call(this,age);
    }
    var test = new Child(21);
    alert(test.age);//21
    alert(test.name);//mike,jack,smith
    test.name.push('bill');
    alert(test.name);//mike,jack,smith,bill
</script>

借用構造函數雖然解決了剛才兩種問題，但沒有原型，則復用無從談起，所以我們需要原型鏈+借用構造函數的模式，這種模式稱為組合繼承

組合繼承

<script>
    function Parent(age){
        this.name = ['mike','jack','smith'];
        this.age = age;
    }
    Parent.prototype.run = function () {
        return this.name  + ' are both' + this.age;
    };
    function Child(age){
        Parent.call(this,age);//對象冒充，給超類型傳參
    }
    Child.prototype = new Parent();//原型鏈繼承
    var test = new Child(21);//寫new Parent(21)也行
    alert(test.run());//mike,jack,smith are both21
</script>

組合式繼承是比較常用的一種繼承方法，其背后的思路是使用原型鏈實現對原型屬性和方法的繼承，而通過借用構造函數來實現對實例屬性的繼承。這樣，既通過在原型上定義方法實現了函數復用，又保證每個實例都有它自己的屬性。

call()的用法：調用一個對象的一個方法，以另一個對象替換當前對象。

call([thisObj[,arg1[, arg2[, [,.argN]]]]])

原型式繼承

這種繼承借助原型并基于已有的對象創建新對象，同時還不用創建自定義類型的方式稱為原型式繼承

<script>
     function obj(o){
         function F(){}
         F.prototype = o;
         return new F();
     }
    var box = {
        name : 'trigkit4',
        arr : ['brother','sister','baba']
    };
    var b1 = obj(box);
    alert(b1.name);//trigkit4
 
    b1.name = 'mike';
    alert(b1.name);//mike
 
    alert(b1.arr);//brother,sister,baba
    b1.arr.push('parents');
    alert(b1.arr);//brother,sister,baba,parents
 
    var b2 = obj(box);
    alert(b2.name);//trigkit4
    alert(b2.arr);//brother,sister,baba,parents
</script>

原型式繼承首先在obj()函數內部創建一個臨時性的構造函數，然后將傳入的對象作為這個構造函數的原型，最后返回這個臨時類型的一個新實例。

寄生式繼承

這種繼承方式是把原型式+工廠模式結合起來，目的是為了封裝創建的過程。

<script>
    function create(o){
        var f= obj(o);
        f.run = function () {
            return this.arr;//同樣，會共享引用
        };
        return f;
    }
</script>

組合式繼承的小問題

組合式繼承是js最常用的繼承模式，但組合繼承的超類型在使用過程中會被調用兩次；一次是創建子類型的時候，另一次是在子類型構造函數的內部

<script>
    function Parent(name){
        this.name = name;
        this.arr = ['哥哥','妹妹','父母'];
    }
 
    Parent.prototype.run = function () {
        return this.name;
    };
 
    function Child(name,age){
        Parent.call(this,age);//第二次調用
        this.age = age;
    }
 
    Child.prototype = new Parent();//第一次調用
</script>

以上代碼是之前的組合繼承，那么寄生組合繼承，解決了兩次調用的問題。

寄生組合式繼承

<script>
    function obj(o){
        function F(){}
        F.prototype = o;
        return new F();
    }
    function create(parent,test){
        var f = obj(parent.prototype);//創建對象
        f.constructor = test;//增強對象
    }
 
    function Parent(name){
        this.name = name;
        this.arr = ['brother','sister','parents'];
    }
 
    Parent.prototype.run = function () {
        return this.name;
    };
 
    function Child(name,age){
        Parent.call(this,name);
        this.age =age;
    }
 
    inheritPrototype(Parent,Child);//通過這里實現繼承
 
    var test = new Child('trigkit4',21);
    test.arr.push('nephew');
    alert(test.arr);//
    alert(test.run());//只共享了方法
 
    var test2 = new Child('jack',22);
    alert(test2.arr);//引用問題解決
</script>

call和apply

全局函數apply和call可以用來改變函數中this的指向，如下：

 // 定義一個全局函數
    function foo() {
        console.log(this.fruit);
    }
    
    // 定義一個全局變量
    var fruit = "apple";
    // 自定義一個對象
    var pack = {
        fruit: "orange"
    };
    
    // 等價于window.foo();
    foo.apply(window);  // "apple",此時this等于window
    // 此時foo中的this === pack
    foo.apply(pack);    // "orange"

簡單原型鏈

這是實現繼承最簡單的方式了，真的超簡單，核心就一句話（在代碼中用注釋標明了）

1.具體實現

function Super(){
    this.val = 1;
    this.arr = [1];
}
function Sub(){
    // ...
}
Sub.prototype = new Super();    // 核心
 
var sub1 = new Sub();
var sub2 = new Sub();
sub1.val = 2;
sub1.arr.push(2);
alert(sub1.val);    // 2
alert(sub2.val);    // 1
 
alert(sub1.arr);    // 1, 2
alert(sub2.arr);    // 1, 2

2.核心

拿父類實例來充當子類原型對象

3.優缺點

優點：

簡單，易于實現

缺點：

修改sub1.arr后sub2.arr也變了，因為來自原型對象的引用屬性是所有實例共享的。可以這樣理解：執行sub1.arr.push(2);先對sub1進行屬性查找，找遍了實例屬性（在本例中沒有實例屬性），沒找到，就開始順著原型鏈向上找，拿到了sub1的原型對象，一搜身，發現有arr屬性。于是給arr末尾插入了2，所以sub2.arr也變了
創建子類實例時，無法向父類構造函數傳參

借用構造函數

簡單原型鏈真夠簡單，可是存在2個致命缺點簡直不能用，于是上個世紀末的jsers就想辦法fix這2個缺陷，然后出現了借用構造函數方式

具體實現

function Super(val){
this.val = val;
this.arr = [1];
```
 this.fun = function(){
     // ...
 }
```
}
function Sub(val){
Super.call(this, val); // 核心
// ...
}

var sub1 = new Sub(1);
var sub2 = new Sub(2);
sub1.arr.push(2);
alert(sub1.val); // 1
alert(sub2.val); // 2

alert(sub1.arr); // 1, 2
alert(sub2.arr); // 1

alert(sub1.fun === sub2.fun); // false
核心

借父類的構造函數來增強子類實例，等于是把父類的實例屬性復制了一份給子類實例裝上了（完全沒有用到原型）

優缺點

優點：

解決了子類實例共享父類引用屬性的問題
創建子類實例時，可以向父類構造函數傳參
P.S.前輩就這么高效，兩個缺陷瞬間修復

缺點：

無法實現函數復用，每個子類實例都持有一個新的fun函數，太多了就會影響性能，內存爆炸。。
P.S.好吧，剛修復了共享引用屬性的問題，又出現了這個新問題。

組合繼承（最常用）

目前我們的借用構造函數方式還是有問題（無法實現函數復用），沒關系，接著修復，jsers吭哧吭哧又搞出了組合繼承

具體實現

function Super(){
// 只在此處聲明基本屬性和引用屬性
this.val = 1;
this.arr = [1];
}
// 在此處聲明函數
Super.prototype.fun1 = function(){};
Super.prototype.fun2 = function(){};
//Super.prototype.fun3...
function Sub(){
Super.call(this); // 核心
// ...
}
Sub.prototype = new Super(); // 核心

var sub1 = new Sub(1);
var sub2 = new Sub(2);
alert(sub1.fun === sub2.fun); // true
核心

把實例函數都放在原型對象上，以實現函數復用。同時還要保留借用構造函數方式的優點，通過Super.call(this);繼承父類的基本屬性和引用屬性并保留能傳參的優點；通過Sub.prototype = new Super();繼承父類函數，實現函數復用

優缺點

優點：

*　不存在引用屬性共享問題
*　可傳參
*　函數可復用
缺點:

*　（一點小瑕疵）子類原型上有一份多余的父類實例屬性，因為父類構造函數被調用了兩次，生成了兩份，而子類實例上的那一份屏蔽了子類原型上的。。。又是內存浪費，比剛才情況好點，不過確實是瑕疵
P.S.如果無法理解這個”多余“，可以查看黯羽輕揚：JS學習筆記2_面向對象，文章末尾有更詳細的解釋．

寄生組合繼承（最佳方式）

從名字就能看出又是對組合繼承的優化，不是說組合繼承有瑕疵嗎，沒關系，我們接著追求完美

具體實現

function beget(obj){ // 生孩子函數 beget：龍beget龍，鳳beget鳳。
var F = function(){};
F.prototype = obj;
return new F();
}
function Super(){
// 只在此處聲明基本屬性和引用屬性
this.val = 1;
this.arr = [1];
}
// 在此處聲明函數
Super.prototype.fun1 = function(){};
Super.prototype.fun2 = function(){};
//Super.prototype.fun3...
function Sub(){
Super.call(this); // 核心
// ...
}
var proto = beget(Super.prototype); // 核心
proto.constructor = Sub; // 核心
Sub.prototype = proto; // 核心

var sub = new Sub();
alert(sub.val);
alert(sub.arr);
P.S.等等，生孩子函數是啥東西，怎么沒聽過？還有標明了核心的3句話，怎么沒看明白？別著急，我們喝杯茶接著看
核心

用beget(Super.prototype);切掉了原型對象上多余的那份父類實例屬性

P.S.啥？沒看明白？哦哦~，忘記說原型式和寄生式繼承了，就說怎么總覺得忘了鎖門。。這記性

P.S.寄生組合式繼承，這名字不是很貼切，和寄生式繼承關系并不是特別大

優缺點

優點：完美了

缺點：理論上沒有了（如果用起來麻煩不算缺點的話。。）

P.S.用起來麻煩是一方面，另一方面是因為寄生組合式繼承出現的比較晚，是21世紀初的東西，大家等不起這么久，所以組合繼承是最常用的，而這個理論上完美的方案卻只是課本上的最佳方式了

原型式

其實介紹完上面的完美方案就可以結束了，但從組合繼承到完美方案好像有一段不小的思維跳躍，有必要把故事說清楚

1.　具體實現

function beget(obj){   // 生孩子函數 beget：龍beget龍，鳳beget鳳。
    var F = function(){};
    F.prototype = obj;
    return new F();
}
function Super(){
    this.val = 1;
    this.arr = [1];
}
 
// 拿到父類對象
var sup = new Super();
// 生孩子
var sub = beget(sup);   // 核心
// 增強
sub.attr1 = 1;
sub.attr2 = 2;
//sub.attr3...
 
alert(sub.val);     // 1
alert(sub.arr);     // 1
alert(sub.attr1);   // 1

P.S.誒~看到了沒，生孩子函數beget出現了

2.　核心

用生孩子函數得到得到一個“純潔”的新對象（“純潔”是因為沒有實例屬性），再逐步增強之（填充實例屬性）

P.S.ES5提供了Object.create()函數，內部就是原型式繼承，IE9+支持

3.　優缺點

優點：

從已有對象衍生新對象，不需要創建自定義類型（更像是對象復制，而不是繼承。。）
缺點：
原型引用屬性會被所有實例共享，因為是用整個父類對象來充當了子類原型對象，所以這個缺陷無可避免
無法實現代碼復用（新對象是現取的，屬性是現添的，都沒用函數封裝，怎么復用）
P.S.這東西和繼承有很大關系嗎？為什么尼古拉斯把它也列為實現繼承的一種方式？關系不大，但有一定關系

6種繼承方式的聯系

繼承.jpg

P.S.虛線表示輔助作用，實線表示決定性作用

轉自文章

Web最新資訊，請關注我的微信公眾號“一起玩前端”或掃描二維碼關注.

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

JavaScript中的繼承方式

JavaScript中的繼承方式

原型式繼承與類式繼承

原型鏈繼承

確定原型和實例的關系

d借用構造函數（類式繼承）

組合繼承

原型式繼承

寄生式繼承

組合式繼承的小問題

寄生組合式繼承

call和apply

簡單原型鏈

2.核心

3.優缺點

優點：

缺點：

借用構造函數

組合繼承（最常用）

寄生組合繼承（最佳方式）

原型式

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

JavaScript中的繼承方式

原型式繼承與類式繼承

原型鏈繼承

確定原型和實例的關系

d借用構造函數（類式繼承）

組合繼承

原型式繼承

寄生式繼承

組合式繼承的小問題

寄生組合式繼承

call和apply

簡單原型鏈

2.核心

3.優缺點

優點：

缺點：

借用構造函數

組合繼承（最常用）

寄生組合繼承（最佳方式）

原型式

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频