2. 程式人生 > >簡單粗暴地理解js原型鏈--js面向對象編程

簡單粗暴地理解js原型鏈--js面向對象編程

阿新 • • 發佈：2017-08-03
所有 類的構造函數 ddr cit gif 人的 all static 到你

原型鏈理解起來有點繞了，網上資料也是很多，每次晚上睡不著的時候總喜歡在網上找點原型鏈和閉包的文章看，效果極好。

不要糾結於那一堆術語了，那除了讓你腦筋擰成麻花，真的不能幫你什麽。簡單粗暴點看原型鏈吧，想點與代碼無關的事，比如人、妖以及人妖。

1）人是人他媽生的，妖是妖他媽生的。人和妖都是對象實例，而人他媽和妖他媽就是原型。原型也是對象，叫原型對象。

技術分享

2）人他媽和人他爸啪啪啪能生出一堆人寶寶、妖他媽和妖他爸啪啪啪能生出一堆妖寶寶，啪啪啪就是構造函數，俗稱造人。

技術分享

3）人他媽會記錄啪啪啪的信息，所以可以通過人他媽找到啪啪啪的信息，也就是說能通過原型對象找到構造函數。

4）人他媽可以生很多寶寶，但這些寶寶只有一個媽媽，這就是原型的唯一性。

5）人他媽也是由人他媽他媽生的，通過人他媽找到人他媽他媽，再通過人他媽他媽找到人他媽他媽……，這個關系叫做原型鏈。

技術分享

6）原型鏈並不是無限的，當你通過人他媽一直往上找，最後發現你會發現人他媽他媽他媽……的他媽都不是人，也就是原型鏈最終指向null。

7）人他媽生的人會有人的樣子，妖他媽生的妖會有妖的醜陋，這叫繼承。

技術分享

8）你繼承了你媽的膚色，你媽繼承了你媽他媽的膚色，你媽他媽……，這就是原型鏈的繼承。

9）你沒有家，那你家指的就是你媽家；你媽也沒有家，那你家指的就是你媽他媽家……這就是原型鏈的向上搜索。

10）你會繼承你媽的樣子，但是你也可以去染發洗剪吹，就是說對象的屬性可以自定義，會覆蓋繼承得到的屬性。

技術分享

11）雖然你洗剪吹了染成黃毛了，但你不能改變你媽的樣子，你媽生的弟弟妹妹跟你的黃毛洗剪吹沒一點關系，就是說對象實例不能改動原型的屬性。

12）但是你家被你玩火燒了的話，那就是說你家你媽家你弟們家都被燒了，這就是原型屬性的共享。

13）你媽外號阿珍，鄰居大娘都叫你阿珍兒，但你媽頭發從飄柔做成了金毛獅王後，隔壁大嬸都改口叫你金毛獅王子，這叫原型的動態性。

14）你媽愛美，又跑到韓國整形，整到你媽他媽都認不出來，即使你媽頭發換回飄柔了，但隔壁鄰居還是叫你金毛獅王子。因為沒人認出你媽，整形後的你媽已經回爐再造了，這就是原型的整體重寫。

技術分享

尼瑪！你特麽也是夠了！ Don‘t BB！ Show me the code！

function Person (name) { this.name = name; }
function Mother () { }
Mother.prototype = {    //Mother的原型
    age: 18,
    home: [‘Beijing‘, ‘Shanghai‘]
};
Person.prototype = new Mother(); //Person的原型為Mother

//用chrome調試工具查看，提供了__proto__接口查看原型
var p1 = new Person(‘Jack‘); //p1:‘Jack‘; __proto__:18,[‘Beijing‘,‘Shanghai‘]
var p2 = new Person(‘Mark‘); //p2:‘Mark‘; __proto__:18,[‘Beijing‘,‘Shanghai‘]

p1.age = 20;  
/* 實例不能改變原型的基本值屬性，正如你洗剪吹染黃毛跟你媽無關
 * 在p1實例下增加一個age屬性的普通操作，與原型無關。跟var o={}; o.age=20一樣。
 * p1：下面多了個屬性age，而__proto__跟 Mother.prototype一樣，age=18。
 * p2：只有屬性name，__proto__跟 Mother.prototype一樣
 */

p1.home[0] = ‘Shenzhen‘; 
/* 原型中引用類型屬性的共享，正如你燒了你家，就是燒了你全家的家
 * 這個先過，下文再仔細嘮叨一下可好？
 * p1：‘Jack‘,20; __proto__:18,[‘Shenzhen‘,‘Shanghai‘]
 * p2：‘Mark‘;    __proto__:18,[‘Shenzhen‘,‘Shanghai‘]
 */

p1.home = [‘Hangzhou‘, ‘Guangzhou‘]; 
/* 其實跟p1.age=20一樣的操作。換成這個理解: var o={}; o.home=[‘big‘,‘house‘]
 * p1：‘Jack‘,20,[‘Hangzhou‘,‘Guangzhou‘]; __proto__:18,[‘Shenzhen‘,‘Shanghai‘]
 * p2：‘Mark‘;                             __proto__:18,[‘Shenzhen‘,‘Shanghai‘]
 */

delete p1.age;    
/* 刪除實例的屬性之後，原本被覆蓋的原型值就重見天日了。正如你剃了光頭，遺傳的迷人小卷發就長出來了。
 * 這就是向上搜索機制，先搜你，然後你媽，再你媽他媽，所以你媽的改動會動態影響你。
 * p1：‘Jack‘,[‘Hangzhou‘,‘Guangzhou‘]; __proto__:18,[‘Shenzhen‘,‘Shanghai‘]
 * p2：‘Mark‘;                          __proto__:18,[‘Shenzhen‘,‘Shanghai‘]
 */


Person.prototype.lastName = ‘Jin‘; 
/* 改寫原型，動態反應到實例中。正如你媽變新潮了，鄰居提起你都說是潮婦的兒子
 * 註意，這裏我們改寫的是Person的原型，就是往Mother裏加一個lastName屬性，等同於Mother.lastName=‘Jin‘
 * 這裏並不是改Mother.prototype，改動不同的層次，效果往往會有很大的差異。
 * p1：‘Jack‘,[‘Hangzhou‘,‘Guangzhou‘]; __proto__:‘jin‘;__proto__:18,[‘Shenzhen‘,‘Shanghai‘]
 * p2：‘Mark‘;                          __proto__:‘jin‘;__proto__:18,[‘Shenzhen‘,‘Shanghai‘]
 */

Person.prototype = { 
    age: 28, 
    address: { country: ‘USA‘, city: ‘Washington‘ }
};
var p3 = new Person(‘Obama‘); 
/* 重寫原型！這個時候Person的原型已經完全變成一個新的對象了，也就是說Person換了個媽，叫後媽。
 * 換成這樣理解：var a=10; b=a; a=20; c=a。所以b不變，變得是c，所以p3跟著後媽變化，與親媽無關。
 * p1：‘Jack‘,[‘Hangzhou‘,‘Guangzhou‘]; __proto__:‘jin‘;__proto__:18,[‘Shenzhen‘,‘Shanghai‘]
 * p2：‘Mark‘;                          __proto__:‘jin‘;__proto__:18,[‘Shenzhen‘,‘Shanghai‘]
 * p3:‘Obama‘;__proto__: 28 {country: ‘USA‘, city: ‘Washington‘}
 */


Mother.prototype.no = 9527;
/* 改寫原型的原型，動態反應到實例中。正如你媽他媽變新潮了，鄰居提起你都說你丫外婆真潮。
 * 註意，這裏我們改寫的是Mother.prototype，p1p2會變，但上面p3跟親媽已經了無瓜葛了，不影響他。
 * p1：‘Jack‘,[‘Hangzhou‘,‘Guangzhou‘]; __proto__:‘jin‘;__proto__:18,[‘Shenzhen‘,‘Shanghai‘],9527
 * p2：‘Mark‘;                          __proto__:‘jin‘;__proto__:18,[‘Shenzhen‘,‘Shanghai‘],9527
 * p3:‘Obama‘;__proto__: 28 {country: ‘USA‘, city: ‘Washington‘}
 */

Mother.prototype = { 
    car: 2, 
    hobby: [‘run‘,‘walk‘]
};
var p4 = new Person(‘Tony‘);
/* 重寫原型的原型！這個時候Mother的原型已經完全變成一個新的對象了！人他媽換了個後媽！
 * 由於上面Person與Mother已經斷開聯系了，這時候Mother怎麽變已經不影響Person了。
 * p4:‘Tony‘;__proto__: 28 {country: ‘USA‘, city: ‘Washington‘}
 */
 
Person.prototype = new Mother(); //再次綁定
var p5 = new Person(‘Luffy‘);
// 這個時候如果需要應用這些改動的話，那就要重新將Person的原型綁到mother上了
// p5:‘Luffy‘;__proto__: 2, [‘run‘,‘walk‘]

p1.__proto__.__proto__.__proto__.__proto__ //null，你說原型鏈的終點不是null？
Mother.__proto__.__proto__.__proto__    //null，你說原型鏈的終點不是null？

看完基本能理解了吧？

現在再來說說 p1.age = 20、p1.home = [‘Hangzhou‘, ‘Guangzhou‘] 和 p1.home[0] = ‘Shenzhen‘ 的區別。 p1.home[0] = ‘Shenzhen‘; 總結一下是 p1.object.method，p1.object.property 這樣的形式。

p1.age = 20; p1.home = [‘Hangzhou‘, ‘Guangzhou‘];這兩句還是比較好理解的，先忘掉原型吧，想想我們是怎麽為一個普通對象增加屬性的：

var obj = new Object();
obj.name=‘xxx‘; 
obj.num = [100, 200];

這樣是不是就理解了呢？一樣一樣的呀。

那為什麽 p1.home[0] = ‘Shenzhen‘ 不會在 p1 下創建一個 home 數組屬性，然後將其首位設為 ‘Shenzhen‘呢？ 我們還是先忘了這個，想想上面的obj對象，如果寫成這樣： var obj.name = ‘xxx‘, obj.num = [100, 200]，能得到你要的結果嗎？ 顯然，除了報錯你什麽都得不到。因為obj還未定義，又怎麽能往裏面加入東西呢？同理，p1.home[0]中的 home 在 p1 下並未被定義，所以也不能直接一步定義 home[0] 了。如果要在p1下創建一個 home 數組，當然是這麽寫了：

p1.home = []; 
p1.home[0] = ‘Shenzhen‘;

這不就是我們最常用的辦法嗎？

而之所以 p1.home[0] = ‘Shenzhen‘ 不直接報錯，是因為在原型鏈中有一個搜索機制。當我們輸入 p1.object 的時候，原型鏈的搜索機制是先在實例中搜索相應的值，找不到就在原型中找，還找不到就再往上一級原型中搜索……一直到了原型鏈的終點，就是到null還沒找到的話，就返回一個 undefined。當我們輸入 p1.home[0] 的時候，也是同樣的搜索機制，先搜索 p1 看有沒有名為 home 的屬性和方法，然後逐級向上查找。最後我們在Mother的原型裏面找到了，所以修改他就相當於修改了 Mother 的原型啊。

一句話概括：p1.home[0] = ‘Shenzhen‘ 等同於 Mother.prototype.home[0] = ‘Shenzhen‘。

由上面的分析可以知道，原型鏈繼承的主要問題在於屬性的共享，很多時候我們只想共享方法而並不想要共享屬性，理想中每個實例應該有獨立的屬性。因此，原型繼承就有了下面的兩種改良方式：

1）組合繼承

function Mother (age) {
    this.age = age;
    this.hobby = [‘running‘,‘football‘]
}
Mother.prototype.showAge = function () {
    console.log(this.age); 
};

function Person (name, age) { 
    Mother.call(this, age);        //第二次執行
    this.name = name; 
}
Person.prototype = new Mother();     //第一次執行
Person.prototype.constructor = Person;
Person.prototype.showName = function () {
    console.log(this.name);
}

var p1 = new Person(‘Jack‘, 20); 
p1.hobby.push(‘basketball‘);  //p1:‘Jack‘; __proto__:20,[‘running‘,‘football‘]
var p2 = new Person(‘Mark‘, 18);  //p2:‘Mark‘; __proto__:18,[‘running‘,‘football‘]

結果是醬紫的：

技術分享 技術分享

這裏第一次執行的時候，得到 Person.prototype.age = undefined, Person.prototype.hobby = [‘running‘,‘football‘]，第二次執行也就是 var p1 = new Person(‘Jack‘, 20) 的時候，得到 p1.age =20, p1.hobby = [‘running‘,‘football‘]，push後就變成了 p1.hobby = [‘running‘,‘football‘, ‘basketball‘]。其實分辨好 this 的變化，理解起來也是比較簡單的，把 this 簡單替換一下就能得到這個結果了。 如果感覺理解起來比較繞的話，試著把腦子裏面的概念扔掉吧，把自己當瀏覽器從上到下執行一遍代碼，結果是不是就出來了呢？

通過第二次執行原型的構造函數 Mother()，我們在對象實例中復制了一份原型的屬性，這樣就做到了與原型屬性的分離獨立。細心的你會發現，我們第一次調用 Mother()，好像什麽用都沒有呢，能不調用他嗎？可以，就有了下面的寄生組合式繼承。

2）寄生組合式繼承

function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}

function inheritPrototype(Person, Mother){
    var prototype = object(Mother.prototype); 
    prototype.constructor = Person;    
    Person.prototype = prototype;    
}
                        
function Mother (age) {
    this.age = age;
    this.hobby = [‘running‘,‘football‘]
}
Mother.prototype.showAge = function () {
    console.log(this.age); 
};

function Person (name, age) { 
    Mother.call(this, age);
    this.name = name; 
}

inheritPrototype(Person, Mother);

Person.prototype.showName = function () {
    console.log(this.name);
}

var p1 = new Person(‘Jack‘, 20); 
p1.hobby.push(‘basketball‘);//p1:‘Jack‘; __proto__:20,[‘running‘,‘football‘]
var p2 = new Person(‘Mark‘, 18); //p2:‘Mark‘; __proto__:18,[‘running‘,‘football‘]

結果是醬紫的：

技術分享 技術分享

原型中不再有 age 和 hobby 屬性了，只有兩個方法，正是我們想要的結果！

關鍵點在於 object(o) 裏面，這裏借用了一個臨時對象來巧妙避免了調用new Mother()，然後將原型為 o 的新對象實例返回，從而完成了原型鏈的設置。很繞，對吧，那是因為我們不能直接設置 Person.prototype = Mother.prototype 啊。

小結

說了這麽多，其實核心只有一個：屬性共享和獨立的控制，當你的對象實例需要獨立的屬性，所有做法的本質都是在對象實例裏面創建屬性。若不考慮太多，你大可以在Person裏面直接定義你所需要獨立的屬性來覆蓋掉原型的屬性。總之，使用原型繼承的時候，要對於原型中的屬性要特別註意，因為他們都是牽一發而動全身的存在。

下面簡單羅列下js中創建對象的各種方法，現在最常用的方法是組合模式，熟悉的同學可以跳過到文章末尾點贊了。

1）原始模式

//1.原始模式，對象字面量方式
var person = { 
    name: ‘Jack‘,
    age: 18,
    sayName: function () { alert(this.name); }
};
//1.原始模式，Object構造函數方式
var person = new Object();
person.name = ‘Jack‘;
person.age = 18;
person.sayName = function () {
    alert(this.name);
};

顯然，當我們要創建批量的person1、person2……時，每次都要敲很多代碼，資深copypaster都吃不消！然後就有了批量生產的工廠模式。

2）工廠模式

//2.工廠模式，定義一個函數創建對象
function creatPerson (name, age) {
    var temp = new Object(); 
    person.name = name;
    person.age = age;
    person.sayName = function () {
        alert(this.name);
    };
    return temp; 
}

工廠模式就是批量化生產，簡單調用就可以進入造人模式（技術分享啪啪啪……技術分享技術分享）。指定姓名年齡就可以造一堆小寶寶啦，解放雙手。但是由於是工廠暗箱操作的，所以你不能識別這個對象到底是什麽類型、是人還是狗傻傻分不清（instanceof 測試為 Object），另外每次造人時都要創建一個獨立的temp對象，代碼臃腫，雅蠛蝶啊。

3）構造函數

//3.構造函數模式，為對象定義一個構造函數
function Person (name, age) {
    this.name = name;
    this.age = age;
    this.sayName = function () {
        alert(this.name);
    };    
}
var p1 = new Person(‘Jack‘, 18); //創建一個p1對象
Person(‘Jack‘, 18);    //屬性方法都給window對象，window.name=‘Jack‘，window.sayName()會輸出Jack

構造函數與C++、JAVA中類的構造函數類似，易於理解，另外Person可以作為類型識別（instanceof 測試為 Person 、Object）。但是所有實例依然是獨立的，不同實例的方法其實是不同的函數。這裏把函數兩個字忘了吧，把sayName當做一個對象就好理解了，就是說張三的 sayName 和李四的 sayName是不同的存在，但顯然我們期望的是共用一個 sayName 以節省內存。

4）原型模式

//4.原型模式，直接定義prototype屬性
function Person () {}
Person.prototype.name = ‘Jack‘;
Person.prototype.age = 18;
Person.prototype.sayName = function () { alert(this.name); };
//4.原型模式，字面量定義方式
function Person () {}
Person.prototype = {
    name: ‘Jack‘,
    age: 18,
    sayName: function () { alert(this.name); }
};
var p1 = new Person(); //name=‘Jack‘
var p2 = new Person(); //name=‘Jack‘

這裏需要註意的是原型屬性和方法的共享，即所有實例中都只是引用原型中的屬性方法，任何一個地方產生的改動會引起其他實例的變化。

5）混合模式（構造+原型）

//5. 原型構造組合模式，
function Person (name, age) {
    this.name = name;
    this.age = age;
}
Person.prototype = {
    hobby: [‘running‘,‘football‘];
    sayName: function () { alert(this.name); },
    sayAge: function () { alert(this.age); }
};
var p1 = new Person(‘Jack‘, 20); 
//p1:‘Jack‘,20; __proto__: [‘running‘,‘football‘],sayName,sayAge
var p2 = new Person(‘Mark‘, 18); 
//p1:‘Mark‘,18;__proto__: [‘running‘,‘football‘],sayName,sayAge

做法是將需要獨立的屬性方法放入構造函數中，而可以共享的部分則放入原型中，這樣做可以最大限度節省內存而又保留對象實例的獨立性。

簡單粗暴地理解js原型鏈--js面向對象編程

相關推薦

簡單粗暴地理解js原型鏈--js面向對象編程

所有 類的構造函數 ddr cit gif 人的 all static 到你 原型鏈理解起來有點繞了，網上資料也是很多，每次晚上睡不著的時候總喜歡在網上找點原型鏈和閉包的文章看，效果極好。 不要糾結於那一堆術語了，那除了讓你腦筋擰成麻花，真的不能幫你什麽。簡單粗暴點看原型鏈

2017.05.06FreeCodeCamp編程之JS面向對象編程學習

支持 concat lte red true 轉化 指向 -1 方法的參數 1.構造對象的方法： ① ②使用構造函數來創建對象。構造函數 通常使用大寫字母開頭，以便把自己和其他普通函數區別開。 在 構造函數 中， this 指向被此 構造函數 創建出來的 對象 。

JavaScript面向對象編程（9）高速構建繼承關系之整合原型鏈

eight family per ria code prot style triangle super 前面我們鋪墊了非常多細節。是為了讓大家更加明晰prototype的使用細節； 如今能夠將前面的知識整合起來，寫一個函數用於高速構建基於原型鏈的繼承關系了： funct

js面向對象編程：怎樣定義常量？

asc pri lower script 面向 ava 實現 get ttr js中有一個keywordconst,但眼下的瀏覽器似乎還不支持，假設一定要定義一些常量，事實上能夠使用閉包，匿名函數實現常量的定義。 比如： var Class = (function

js面向對象編程： js類定義函數時prototype和this差別？

this script 私有字段 new art func 內部 name prot 在面向對象編寫js腳本時，定義實例方法主要有兩種 例如以下： function ListCommon2(afirst) { var first=afirst;

js面向對象編程——創建對象

分享 語法檢查 這就是 編程 spa fine 全局 his 定義 JavaScript對每個創建的對象都會設置一個原型，指向它的原型對象。 當我們用obj.xxx訪問一個對象的屬性時，JavaScript引擎先在當前對象上查找該屬性，如果沒有找到，就到其原型對象上找，如果

JS的面向對象編程

() 三種 javascrip 屬性 執行 一點 輔助方法 func 內容 一、什麽是"非構造函數"的繼承？ 比如，現在有一個對象，叫做"中國人"。 　　var Chinese = {　　　　nation:‘中國‘　　}; 還有一個對象，叫做"醫生"。 　　var

JS面向對象編程

tint 寫代碼 ons cti 面向對象編程 沒有 clas inter () 什麽是面向對象編程（OOP）？用對象的思想去寫代碼，就是面向對象編程。 面向對象編程的特點 抽象：抓住核心問題 封裝：只能通過對象來訪問方法 繼承：從已有對象上繼承出新的對象 多態：多對象的

js原生實現輪播圖效果（面向對象編程）

alt 狀態 off wid 編程） .proto eat doc 持續時間 面向對象編程js原生實現輪播圖效果 1.先看效果圖 2.需要實現的功能： 自動輪播 點擊左右箭頭按鈕無縫輪播 點擊數字按鈕切換圖片 分析：如何實現無縫輪播？ 在一個固定大小的相框裏有一個ul

面向對象編程思想-簡單工廠模式

htm using 希望 耦合度 www 生活 html 組織 cto 一、引言 簡單工廠、工廠方法、抽象工廠模式都屬於設計模式中的創建型設計模式，它們幫助我們把對象的實例化部分抽取出來，進而優化系統架構，提高系統的擴展性。本文介紹一個比較容易理解的模式-簡單工廠模式。 二

面向對象編程思想-原型模式

復雜度 pmo console 們的 get clone 一段 創建過程 產生 一、引言 相信大家都看過西遊記中孫悟空拔一根汗毛吹出千萬只猴子，可有沒有想過如果這些猴子一只一只的去經歷和孫悟空一樣的成長過程才能產生，這是何其的復雜和耗費精力啊？！類比在程序設計中，當需要創建

面向對象編程和簡單UI界面的實現

.com gae bcv hab iuc fan get dea lan 615E雲3419NDhttp://www.facebolw.com/space/2103772/following 20j怖境幟5盎XNhttp://weibo.com/p/100505636741

C# 面向對象編程的核心技能的理解學習記錄

開放 封閉修改 實現接口 提升自己 同時 開發者 公司 基礎 window 學習的困惑 1. 不知道怎麽學習 剛開始學習變成，看了相關的教材，但是沒有體會到什麽是面向對象編程，也不知道怎麽深入學習； 2. 只是盲目的使用 已經工作，也會做一些項目，但是很多時候不明白為

JavaSE基礎 數組 面向對象編程理解部分關鍵字的解釋及用法

java 開發一維數組 數組：可以存儲多個元素並且多個元素是同一種類型的容器 數組的定義: 數據類型[] 數組名; 例如：int[]a; 意義：定義了一個int類型的數組變量a 數據類型 數組名[]; 例如：int a[]; 意

如何快速簡單粗暴地理解Python中的if __name__ == '__main__'

repr uil 文件導入 alc ron ogr num out module 1. 摘要 通俗的理解__name__ == ‘__main__‘：假如你叫小明.py，在朋友眼中，你是小明(__name__ == ‘小明‘)；在你自己眼中，你是你自己(__name__ =

JS原型鏈--js面向物件程式設計

原型鏈理解起來有點繞了，網上資料也是很多，每次晚上睡不著的時候總喜歡在網上找點原型鏈和閉包的文章看，效果極好。 不要糾結於那一堆術語了，那除了讓你腦筋擰成麻花，真的不能幫你什麼。簡單粗暴點看原型鏈吧，想點與程式碼無關的事，比如人、妖以及人妖。 1）人是人他媽生的，妖是

[js高手之路]面向對象+設計模式+繼承一步步改造簡單的四則運算

繼承 設計模式 到目前為止，我已經寫完了面向對象完整的一個系列知識，前面基本屬於理論，原理的理解，接下來，我們就用學到的知識來實戰下吧.看看理解原理和理論是否重要？例子從簡單到復雜一、單體（字面量）封裝加減乘除var Oper = { add : function( n1, n

JS高級. 02 面向對象、創建對象、構造函數、自定義構造函數、原型

浪費 truct 創建過程 spa const 使用 指向 找到 tro 面向對象的三大特性： 　　 封裝 　　　　a) 把一些屬性和方法裝到一個對象裏 　　2. 繼承 　　　　a) js中的繼承是指: 　 　一個對象沒有一些方法和屬性,而另一個對象有

描述下你對js閉包。面向對象、繼承的理解

apply prototype 滿足 編程範式 函數 details 內存 全局 訪問控制 1）閉包理解： 個人理解：閉包就是能夠讀取其他函數內部變量的函數； 使用閉包主要是為了設計私有的方法和變量。閉包的優點是可以避免全局變量的汙染，缺點是閉包會常駐內存，會增大內存使

js常見知識點3.面向對象之繼承、設計模式

環境 設計 方法 nbsp -- div 細節 外部 接口實現 一、面向對象的三大特征 　　建議回復：　 　　封裝：屏蔽內部細節、調用外部接口實現對應功能(函數調用) 　　繼承：子類繼承父類中的屬性和方法 　　多態（js中不存在多態的概念） 二、繼承 　　建議回復：