DIV CSS 佈局教程網

JavaScript Function 函式深度總結:從基礎到閉包與作用域
編輯:JavaScript基礎知識     

這篇筆記把 JavaScript 中 Function 函式的各種知識點做了一次系統整理。函式簡直就是一大物件,各種概念都能牽扯進來,不僅僅是 Function 這個原生引用型別本身的用法,還牽涉到執行環境、作用域、閉包、上下文、私有變數等更深入的知識點。

函式中的 return

  1. return 語句可以不帶任何返回值,在這種情況下(return; 或函式中完全沒有 return 語句時),函式停止執行後會回傳 undefined。這種用法通常用於需要提前結束函式執行、又不需要返回值的場合。
  2. return false 可以阻止元素的預設事件。
  3. return 返回的是它所在函式的返回值。
    function n(){ (function(){ return 5; })(); } n();// undefined //立即執行匿名函數中的return語句其實是返回給它所在的匿名函數的。 function n(){ var num= (function(){ return 5; })(); console.log(num); }

Function 型別
函式本質上是物件,每個函式其實都是 Function 型別的實例。而且與其他引用型別一樣,函式也具備屬性和方法。函式名實際上是一個指向記憶體堆中某個函式物件的指標。

定義函式的方式有三種:

  1. 函式聲明
    function sum(num1,num2){ return num1+num2; }
  2. 函式表達式
    var sum=function(num1,num2){ return num1+num2; };
    定義了一個變數 sum 並將它初始化為一個函式。要留意的是 function 關鍵字後面並沒有函式名,因為使用函式表達式時沒必要寫函式名,透過變數 sum 即可引用函式。另外函式結尾有個分號,就像宣告其他變數一樣。
  3. new 建構函式。雖然這種寫法也算函式表達式,但並不推薦。因為這種語法會導致程式碼被解析兩次(第一次解析常規的 ECMAScript 程式碼,第二次解析傳入建構函式中的字串),會影響效能。使用 Function 建構函式時,它可以接受任意數量的參數,但最後一個參數永遠被當作函式體,前面的參數則對應新函式的形參。 使用不帶圓括號的函式名是在訪問函式指標,而非呼叫函式。
    var sum=new Function('num1','num2','return num1+num2;'); sum;// function anonymous(num1,num2 /**/) { return num1+num2; }

理解參數
ECMAScript 中所有參數傳遞的都是值(即使傳遞引用,傳的也是位址值,並非引用傳遞)。ECMAScript 函式不介意傳進來多少個參數,也不在乎傳進來的參數是什麼型別。之所以如此,是因為 ECMAScript 中的參數在內部是用一個陣列表示的。函式接收到的永遠是這個陣列,而不關心裡面包含哪些參數。在函式體內,可以透過 arguments 物件來訪問這個陣列,從而取得傳遞給函式的每個參數。

function func(){ console.log(Object.prototype.toString.call(arguments)); } func();// [object Arguments]
  1. 關於 arguments 的行為,它的值永遠與對應命名參數的值保持同步,因為 arguments 物件中的值會自動反映到對應的命名參數上。所以修改 arguments[1],也就修改了 num2。不過這並不表示讀取這兩個值會存取同一塊記憶體空間,它們的記憶體空間是獨立的,只是值會同步。
  2. 但如果只傳入了一個參數,那麼 arguments[1] 設置的值不會反映到命名參數中,這是因為 arguments 物件的長度是由傳入參數的個數決定的,而不是由定義函式時的命名參數個數決定的。沒有傳值的命名參數會自動被賦予 undefined,這就跟宣告了變數卻沒初始化一樣。
    function doAdd(num1,num2){ console.log(arguments.length); console.log(num2) arguments[1]=10; console.log(num2); } doAdd(5,0);//2 0 10 doAdd(5);//1 undefiend undefined

沒有重載

ECMAScript 函式無法像傳統意義那樣實現重載。在其他語言(如 Java)中,可以為一個函式編寫兩個定義,只要這兩個定義的簽名(接收參數的型別和數量)不同即可。ECMAScript 無法重載的原因有兩點:

  1. ECMAScript 函式沒有簽名,因為其參數是由包含零個或多個值的陣列表示的。沒有函式簽名,真正的重載就無法做到。在 ECMAScript 中定義兩個同名的函式,這個名字只屬於後定義的那個。若想模擬類似 Java 的重載,其實可以透過判斷傳入函式的參數型別和個數來做出不同響應。
    function reload(){ if(arguments.length==0){ console.log('沒傳參'); }else if(arguments.legth==1){ console.log('傳了一個參數'); } }
  2. 深入理解:把函式名想像成指標,也有助於理解為什麼 ECMAScript 中沒有函式重載的概念。
    function add(){ return 100; } function add(num){ return num+200; } //實際上和下面代碼沒什麼區別 function add(){ return 100; } add=function(num){ return num+200; }

函式聲明和函式表達式

實際上,解析器在向執行環境中載入資料時,對函式聲明和函式表達式並非一視同仁。對於解釋型語言來說,編譯步驟大致為:

  1. 詞法分析(將字元流轉換為記號流,是一對一的硬性翻譯,得到一堆較難理解的記號流)
  2. 語法分析(在這裡進行所謂的變數提升操作,要構造語法樹,若發現無法構造便會拋出語法錯誤,並終止整個程式碼塊的解析)
  3. 之後可能還有語義檢查、程式碼優化等,得到語法樹後就開始解釋執行。解釋型語言不會編譯成二進位碼,而是從語法樹開始執行。

解析器會先讀取函式聲明,並讓它在任何程式碼執行之前就能用。至於函式表達式,則必須等到執行階段才會被真正賦值。這什麼意思呢?雖然兩者都進行了變數提升,待真正執行時會從語法樹中把聲明取出並加入執行環境,但一個是函式提升,一個是變數提升。

//函數聲明 console.log(func);//function func(){} function func(){ } //函數表達式 console.log(func1);// undefined var func1=function(){}; console.log(func1);// function(){}

作為值的函式

因為 ECMAScript 中的函式名本身就是變數,所以函式也可以作為值來使用。不僅可以像傳遞參數那樣把一個函式傳給另一個函式,還可以將一個函式作為另一個函式的結果返回。

function callSomeFunction(someFunction,someArgument){ return someFunction(someArgument); } function concated(str){ return "Hi "+str; } callSomeFunction(concated,'xx');// 'Hi xx' 

從一個函式中返回另一個函式的應用:假設有一個物件陣列,想根據某個物件屬性對陣列排序,但傳給 sort() 方法的比較函式要接收兩個參數,即要比較的值。我們需要一種方式來指明「按照哪個屬性來排序」。這時可以定義一個函式,它接收一個屬性名,然後據此創建一個比較函式。預設情況下,sort 函式會呼叫每個物件的 toString() 方法來確定它們的次序。

function createCompare(property){ return function(obj1,obj2){ var value1=obj1[property], value2=obj2[property]; if(value1<value2) return -1; else if(value1>value2) return 1; else return 0; } }
var data=[{name:'aa',age:20},{name:'bb',age:12},{name:'cc',age:30}]; data.sort(createCompare("age"));// [{name:'bb',age:12},{name:'aa',age:20},{name:'bb',age:30}]

函式的內部屬性

arguments:類陣列物件,包含傳入函式的所有參數。它是每個函式自身的屬性,之所以能直接訪問 arguments,是為了加強 JavaScript 語言的安全性,這樣第三方程式碼就不能在相同的環境下窺視其他程式碼了。

  • callee 屬性:是一個指標,指向擁有 arguments 物件的函式。嚴格模式下訪問它會導致錯誤。
    //一般階乘函數 function factorial(num){ if(num<=1){ return 1;} else { return num*factorial(num-1); } }

    定義階乘函式用到了遞歸演算法,這樣定義沒問題,缺點是這個函式的執行與函式名 factorial 緊緊耦合在一起,萬一出現改變函式指向的情況就不太好了,例如:

    factorial=function(){} factorial(3);// undefiend

    為了消除這種現象,可以改用 arguments.callee:

    function factorial(num){ if(num<=1){ return 1; } else{ return num*arguments.callee(num-1); } }

    這樣無論引用函式時用的是什麼名字,都能保證完成遞歸。

  • caller 屬性:在非嚴格模式下這個屬性始終是 undefined,即使在嚴格模式下訪問也會出錯。增加這個屬性是為了分清 arguments.caller 和函式物件上的 caller 屬性。
    function a(){ return Object.getOwnPropertyNames(arguments); } a();// ["length", "callee"]

this:行為與 Java/C# 中的 this 大致類似,它引用的是函數據以執行的環境物件(當在網頁的全域作用域中呼叫函式時,this 物件引用的就是 window)。
caller:不僅是 ECMAScript5 新增的函式物件上的屬性,也是 arguments 上的屬性,保存著呼叫當前函式的函式的引用。如果是在全域作用域中呼叫當前函式,它的值為 null。
Object.getOwnPropertyNames(Function);// ["length", "name", "arguments", "caller", "prototype"]

function outer(){ inner(); } function inner(){ console.log(inner.caller); //為了實現更松散的耦合,arguments.callee.caller } outer();// function outer(){ inner()}

嚴格模式下不能為函式的 caller 屬性賦值,否則會導致出錯。

函式的屬性和方法

  • length:表示函式希望接收的命名參數個數(也就是定義的形參個數)。
    function sayName(name){ // } function sum(num1,num2){ // } function sayHi(){ // } sayName.length;// 1 sum.length;// 2 sayHi.length;// 0
  • prototype:對於 ECMAScript 中的引用型別而言,prototype 是保存它們所有實例方法的真正所在。諸如 toString 和 valueOf 等方法實際上都保存在 Object.prototype 名下(Function、Array 等原生建構函式會在自己的原型上重寫 toString)。在 ECMAScript5 中,prototype 屬性是不可枚舉的,因此用 for-in 無法發現它。Object.getOwnPropertyDescriptor(Function,'prototype');// Object {writable: false, enumerable: false, configurable: false}
  • 每個函式上都有兩個可用的方法:apply 和 call。這兩個方法實際上位於 Function.prototype 上,是在 JavaScript 引擎內部實現的。因為它們屬於 Function.prototype,所以每個 Function 的實例都能用(自定義的函式也是 Function 的實例)。它們都是在特定的作用域或自定義的上下文中呼叫執行函式,實際上等於設置函式體內 this 物件的值。
  1. apply:參數一為函式在其中執行的作用域,參數二為參數陣列(可以是陣列,也可以是 arguments 物件)。
    function sum(num1,num2){ return num1+num2; } function callSum1(num1,num2){ return sum.apply(this,arguments);//sum.apply(this,[num1,num2]) } callSum1(10,30);// 40

    嚴格模式下,未指定環境物件而呼叫函式時,this 值不會轉型為 window,除非明確把函式添加到某個物件或者呼叫 apply/call,否則 this 值將是 undefined。

  2. call:參數一沒有變化,變化的是其餘參數都直接傳給函式,參數必須都列出來。
    function callSum1(num1,num2){ retrun sum.call(this,num1,num2); } callSum1(10,30);// 40

    call 和 apply 真正強大的地方在於能夠擴充函式賴以執行的作用域,改變函式的執行環境。

  3. bind:ECMAScript5 定義的方法,同樣位於 Function.prototype 上,用於控制函式的執行上下文,會回傳一個新函式,這個函式的 this 值會被綁定到傳給 bind() 的值上。
    window.color="red"; var o={color:'blue'}; function sayColor(){ console.log(this.color); } var newobj=sayColor.bind(o); newobj;// function sayColor(){ console.log(this.color); } newobj==sayColor;// false newobj();// blue

    深入理解:可以將函式綁定到指定環境的函式,接收一個函式與一個環境,回傳在給定環境中呼叫給定函式的函式。

    function bind(func,context){ return function(){ func.apply(context,arguments);//這裡創建了一個閉包,arguments使用的返回的函數的,而不是bind的 } }

    當呼叫回傳的函式時,它會在給定環境中執行被傳入的函式並帶上所有參數。

    function bind(func,context,args){ return function(){ func.call(context,args); }; }
  4. toString、toLocaleString:回傳函式程式碼的字串形式,回傳格式因瀏覽器而異,有的回傳原始碼,有的回傳函式程式碼的內部表示,由於存在差異,用這個也實現不了什麼功能。
  5. valueOf:回傳函式自身的引用。

變數、作用域、記憶體問題
JavaScript 接近詞法作用域,變數的作用域是在定義時決定而非執行時決定,也就是說詞法作用域取決於原始碼。
JavaScript 引擎在執行每個函式實例時,都會為它創建一個執行環境,其中包含一個 AO 變數物件,用來保存內部變數表、內嵌函式表、父級引用列表等語法分析結構(變數提升在語法分析階段就已經完成,並保存在語法樹中,函式實例執行時會把這些資訊複製到 AO 上)。

ECMA-262 定義,JavaScript 松散型別的本質決定了它只在特定時間用於保存特定值的一個名字而已,由於不存在「某變數必須保存何種型別值」的規則,變數的值及其型別可在腳本的生命週期內改變。

  • 基本型別和引用型別的值:ECMAScript 變數可能包含兩種不同型別的值:基本型別值和引用型別值。
  1. 基本型別值:簡單的資料段。
  2. 引用型別值:那些可能由多個值構成的物件,是保存在記憶體中的物件。JavaScript 不允許直接訪問記憶體中的位置,也就是說不能直接操作物件的記憶體空間。操作物件時,實際上是在操作物件的引用而非實際的物件本身,因此引用型別值是按引用訪問的。(這種說法並不嚴密,當複製保存著物件的某個變數時,操作的是物件的引用;但在為物件添加屬性時,操作的則是實際的物件)在將一個值賦給變數時,解析器必須確定這個值是基本型別值還是引用型別值。5 種基本型別:Undefined、Null、Boolean、Number、String(很多語言中字串以物件形式表示而被視為引用型別,但 ECMAScript 放棄了這一傳統)。這 5 種基本型別是按值訪問的,因此可以操作保存在變數中的實際的值。
  • 動態的屬性
  • 複製變數的值:從一個變數向另一個變數複製基本型別值和引用型別值時,也存在差異。複製基本型別值時,會在變數物件上創建一個新值,然後把該值複製到為新變數分配的空間上。而從一個變數向另一個變數賦值引用型別值時,同樣會把存在變數物件中的值複製一份放到新變數的空間中,不同的是,這個值的副本實際上是個指標(可理解為複製了位址值),指向存在堆中的一個物件。複製結束後,兩個變數實際上將引用同一個物件。
  • 傳遞參數:ECMAScript 中所有函式的參數都是按值傳遞的,把函式外部的值複製給函式內部的參數,就像把值從一個變數複製到另一個變數一樣。基本型別值的傳遞如同基本型別變數的複製,引用型別值的傳遞如同引用型別變數的複製。很多人錯誤地認為:在局部作用域中修改的物件會在全域作用域中反映出來,就說明是按引用傳遞的。為了證明物件是按值傳遞的:
    function setName(obj){ obj.name="xx"; obj=new Object(); obj.name="bb"; } var p=new Object(); setName(p); p.name;// "xx"

    如果是按引用傳遞的,即傳的不是位址值而是堆記憶體中整個 p 物件,那麼在 setName 中為它添加了一個名字叫 obj,又添加 name 屬性後,再將這個 obj 內容重新填充為新物件,那麼之前的那個物件就不存在了,更別提有 "xx" 這個屬性了,但 p.name 仍然訪問到了。這說明即使在函式內部修改了參數值,原始的引用仍保持不變。實際上,當在函式內部重寫 obj 時,這個變數引用的就是一個局部物件了,而這個局部物件會在函式執行完畢後被立即銷毀。

  • 類型檢測:檢測一個變數是不是基本型別,用 typeof 是最佳工具,但如果變數的值是除函式以外的物件或 null,typeof 都會回傳 "object";變數值為函式時 typeof 會回傳 "function"(ECMA-262 規定任何在內部實現 [[call]] 方法的物件都應該在應用 typeof 時回傳 "function")。但在檢測引用型別值時,這個運算子用處不大,因為我們並不是想知道它是個物件,而是想知道它是哪一類物件。如果變數是給定引用型別的實例,instanceof 運算子會回傳 true。所有引用型別值都是 Object 的實例。如果用 instanceof 檢測基本型別值,則該運算子始終回傳 false,因為基本型別不是物件。

執行環境及作用域

  • 執行環境(execution context):也稱為作用域,定義了變數或函式有權訪問的其他資料,決定了它們各自的行為。全域執行環境是最外圍的一個執行環境,根據 ECMAScript 實現所在的宿主環境不同,表示執行環境的物件也不一樣,在網頁瀏覽器中全域執行環境是 window 物件。某個執行環境中所有程式碼執行完畢後,該環境會被銷毀,存在其中的所有變數和函式定義也隨之銷毀(全域執行環境直到應用程式退出,例如關閉網頁或瀏覽器時才被銷毀)。每個函式都有自己的執行環境,當執行流進入一個函式時,函式的環境會被推入一個環境堆疊,函式執行後堆疊會將其環境彈出,把控制權返回給之前的執行環境,ECMAScript 程式中的執行流正是由這個機制控制著。函式的每次呼叫都會創建一個新的執行環境。執行環境分為創建和執行兩個階段:
  1. 創建:解析器初始化變數物件或活動物件,它由定義在執行環境中的變數、函式聲明、參數組成。在這個階段,作用域鏈會被初始化,this 的值也最終會被確定。
  2. 執行:程式碼被解釋執行。
  • 變數物件(variable object):環境中定義的所有變數和函式都存在這個物件中。雖然用程式碼無法訪問它,但解析器在處理資料時會在後台使用它。如果這個環境是函式,則將活動物件(activation object)作為變數物件。
  • 作用域(scope)和上下文(context):函式的每次呼叫都有與之緊密相關的作用域和上下文。作用域是基於函式的,上下文是基於物件的。作用域涉及到被呼叫函式中變數的訪問,上下文始終是 this 關鍵字的值,它是擁有當前所執行程式碼的物件的引用,通常取決於函式是如何被呼叫的。
  • 作用域鏈(scope chain):當程式碼在一個環境中執行時,會創建變數物件的作用域鏈,它是保證對執行環境有權訪問的所有變數和函式的有序訪問。作用域鏈的前端始終都是當前執行程式碼所在環境的變數物件。活動物件在最開始時只包含一個變數即 arguments 物件(這個物件在全域環境中不存在),作用域鏈的下一個變數物件來自包含(外部)環境,再下一個則來自再上一層的包含環境,這樣一直延續到全域執行環境。
    var color = "blue"; function changeColor(){ if(color=="blue"){ color="red"; }else{ color="blue"; } } changeColor(); console.log(color);// red

    標識符解析是沿著作用域鏈一級一級搜索標識符的過程。函式 changeColor 的作用域鏈包含兩個物件:它自己的變數物件(其中定義著 arguments 物件)和全域環境的變數物件。能在函式內部訪問到變數 color,就是因為可以在這個作用域鏈中找到它。內部環境可以透過作用域鏈訪問所有外部環境,但外部環境不能訪問內部環境的任何變數和函式。函式參數也被當作變數來對待,因此其訪問規則與執行環境中的其他變數相同。

  • 延長作用域鏈:有些語句可以在作用域的前端臨時添加一個變數物件,該變數物件會在程式碼執行後被移除。當執行流進入下列語句時,作用域鏈就會加長。
  1. try-catch 語句的 catch 塊:對 catch 語句來說,會創建一個新的變數物件,其中包含被拋出的錯誤物件的聲明。在 IE8 以前的版本中,在 catch 語句中捕獲的錯誤物件會被添加到執行環境的變數物件而不是 catch 語句的變數物件,也就是說,即使在 catch 塊的外部也能訪問到錯誤物件。
  2. with 語句:會將指定的物件添加到作用域鏈中。
    function buildUrl(){ var qs="?debug=true"; with(location){ var url=href+qs; } return url; }
    buildUrl();// "https://i.cnblogs.com/EditPosts.aspx?postid=5280805?debug=true"

    with 語句接收的是一個 location 物件,因此其變數物件中就含有 location 物件的所有屬性和方法,且這個變數物件被添加到作用域鏈的最前端。當在 with 語句中引用變數 href(實際引用的是 location.href)時,可以在當前執行環境中找到;當引用變數 qs 時,引用的則是下一級執行環境中的變數。由於 JavaScript 中沒有塊級作用域,所以在函式內部可以訪問 url 才能 return 成功,這說明 url 並沒有被添加到 location 所在的變數物件中。這兩個語句都會在作用域的前端添加一個變數物件。

  • 沒有塊級作用域:在其他類 C 的語言中,由花括號封閉的程式碼塊都有自己的作用域(用 ECMAScript 的話說,就是它們自己的執行環境),因而支持根據條件來定義變數。如果是 C/C++/Java,color 會在 if 語句執行完後被銷毀,但在 JavaScript 中,if 語句裡的變數聲明會將變數添加到當前的執行環境中。
    if(true){ var color="red"; } console.log(color);// red
  1. 宣告變數:使用 var 宣告的變數會自動被添加到最接近的環境中。在函式內部,最接近的環境就是函式的局部環境;在 with 語句中,最接近的環境是函式環境。如果初始化變數時沒有使用 var 宣告,該變數會自動被添加到全域環境。
  2. 查詢標識符:當在某個環境中為了讀取或寫入而引用一個標識符時,必須透過搜索來確定該標識符代表什麼。搜索過程從作用域鏈的前端開始,向上逐級查詢與給定名字匹配的標識符。如果在局部環境中找到了該標識符,搜索停止,變數就緒;如果沒找到,則繼續沿作用域鏈向上搜索,一直追溯到全域環境。如果局部環境存在同名標識符,就不會使用位於父環境中的標識符。

函式表達式

if(condition){ function sayHi(){ console.log("Hi"); } }else{ function sayHi(){ console.log("Yo"); } }

以上程式碼會在 condition 為 true 時使用 sayHi() 的定義,否則使用另一個定義。實際上這在 ECMAScript 中屬於無效語法,JavaScript 引擎會嘗試修正錯誤,將其轉換為合理的狀態,但問題是不同瀏覽器的修正做法並不一樣,大多數瀏覽器會回傳第二個聲明。這種方式很危險,不應該出現在你的程式碼中。修正方式很簡單,改用函式表達式就沒問題了:

var sayHi; if(condition){ sayHi=function(){ console.log("Hi"); } }else{ sayHi=function(){ console.log("Yo"); } }

遞歸

在嚴格模式下,不能透過腳本訪問 arguments.callee,不過可以使用命名函式表達式來完成相同結果。

var factorial=(function f(num){ if(num<=1){ return 1; }else{ return num*f(num-1); } });

注意要用命名函式表達式,單單把命名函式賦值給 factorial 也可以,但並不能透過 f 這個名字訪問它。

閉包

閉包是指有權訪問另一個函式作用域中變數的函式。創建閉包的常見方式,就是在一個函式內部創建另一個函式。之所以能夠訪問外部作用域的變數,是因為內部函式的作用域鏈中包含外部作用域。當一個函式被呼叫時:

  1. 創建一個執行環境及相應的作用域鏈
  2. 使用 arguments 和其他命名參數的值來初始化活動物件,但在作用域鏈中,外部函式的活動物件始終處於第二位,直至作為作用域鏈終點的全域執行環境。
    function compare(value1,value2){ if(value1<value2){ return -1; }else if(value1>value2){ return 1; }else{ return 0; } } var result=compare(5,10);

    當呼叫 compare() 時,會創建一個包含 arguments、value1、value2 的活動物件,全域執行環境的變數物件(包含 result 和 compare)在 compare() 執行環境的作用域鏈中處於第二位。

    後台的每個執行環境都有一個表示變數的物件(變數物件),全域環境的變數物件始終存在,而像 compare() 函式這樣的局部環境的變數物件,則只在函式執行過程中存在。在創建 compare() 函式時,會創建一個預先包含全域物件的作用域鏈,這個作用域鏈被存在 compare 內部的 [[Scope]] 屬性中。當呼叫 compare() 函式時,會為函式創建一個執行環境,然後透過複製函式 [[Scope]] 屬性中的物件構建起執行環境的作用域鏈,此後又有一個活動物件被創建並推入執行環境作用域鏈的最前端。對於這個例子而言,compare 函式的執行環境的作用域鏈包含兩個變數物件:本地活動物件和全域變數物件。顯然,作用域鏈的本質上是一個指向變數物件的指標列表,它只引用但不包含實際的變數物件。

無論什麼時候在函式中訪問一個變數,就會從作用域鏈中搜索具有相應名字的變數。一般來講,當函式執行完後,局部活動物件會被銷毀,記憶體中僅保留全域作用域。但閉包的情況又有所不同:在另一個函式內部定義的函式會將包含函式(外部函式)的活動物件添加到它的作用域鏈裡,當外部函式執行完後,其活動物件不會被銷毀,因為內部函式的作用域鏈仍然在引用這個活動物件。也就是說,只是外部函式它自己的作用域鏈被銷毀了,但活動物件還存在記憶體中,直到內部函式被銷毀後(例如在外部解除了對閉包的引用:func=null;),外部函式的活動物件才會被銷毀。

由於閉包會攜帶包含它的函式的作用域,因此會比其他函式佔用更多記憶體。過多使用閉包可能導致記憶體佔用過多,建議只在絕對必要時再考慮使用。不過像 V8 這樣經過優化的 JavaScript 引擎會嘗試回收被閉包佔用的記憶體。

閉包的缺點:作用域鏈的這種配置機制引出的一個副作用是,閉包只能取得包含函式中任何變數的最後一個值,因為閉包保存的是整個變數物件,而不是某個特殊的變數。

function createFunctions(){ var result=new Array(); for(var i=0;i<3;i++){ result[i]=function(){ return i; }; } return result; }
createFunctions()[0]();// 3
createFunctions()[1]();// 3
createFunctions()[2]();// 3

當執行 createFunctions 時,它的活動物件裡有 arguments=[]、result=undefined、i=undefined,執行完後 result=[function(){return i},function(){return i},function(){return i}],i=3。此時執行 result 陣列時,訪問到的 i 總是 3,因為沿著 function(){return i;} 的作用域鏈查找變數,在外層函式的活動物件上找到的 i 總是 3。陣列中每個函式的作用域鏈中都保存著 createFunctions 的活動物件,所以這些函式引用的都是同一個活動物件、同一個變數 i。

解決方案:我們要的是當時執行時的變數 i,那麼當時把這個 i 臨時保存一下就可以了,保存在哪呢?保存在 function(){return i;} 的活動物件中。怎麼保存呢?傳給 arguments 就好了,但只傳進來還不行:

function createFunctions(){ var result=new Array(); for(var i=0;i<3;i++){ result[i]=function(i){ return i; }; } return result; } createFunctions()[0]();// undefiend

因為訪問 i 的時候會先從自己所在函式執行環境的活動物件搜索起,找到 i 發現 i=undefined 有值就停止向上搜索了。問題出在 result[i]=function(i){return i;} 這句只是表達式的賦值操作,並沒有給匿名函式傳參,也不是執行匿名函式。所以現在需要透過某種方式去執行函式,把 i 的值當實參傳進去。簡單!在匿名函式外部加一層立即執行的匿名函式即可(這也增加了一層作用域)。

function createFunctions(){ var result=new Array(); for(var i=0;i<3;i++){ result[i]=(function(i){ return function(){ return i; } })(i); } return result; } createFunctins()[0]();// 0

this 物件

this 物件是在執行時基於函式的執行環境綁定的:

  1. 全域函式中,this 等於 window
  2. 函式被作為某個物件的方法呼叫時,this 等於那個物件
  3. 匿名函式的執行環境具有全域性,this 指向 window
  4. 透過 call() 或 apply() 改變函式執行環境的情況下,this 就會指向其他物件。

由於閉包編寫方式不同,this 的表現也不同:

var name="the window"; var obj={ name:"the obj", getNameFunc:function(){ //console.log(this==obj); return function(){ console.log(this.name); } } } obj.getNameFunc()();// the window

obj.getNameFunc() 回傳了一個新函式,然後在全域環境中執行該函式。為什麼匿名函式沒有取得其包含作用域的 this 物件呢?每個函式在被呼叫時,都會自動獲得兩個特殊的變數:this(創建作用域時獲得)和 arguments(創建活動物件時獲得),內部函式在搜索這兩個變數時,只會搜索到自己的活動物件為止,因此永遠不可能直接訪問外部函式的這兩個變數。不過把外部函式作用域的 this 存在一個閉包能夠訪問到的變數裡,就可以讓閉包訪問該物件了。

下面幾種情況的 this 比較特殊:

var name="the window"; var obj={ name:"the obj", getName:function(){ return this.name; } }; obj.getName();// "the obj" (obj.getName)();// "the obj" (obj.getName=obj.getName)();// "the window" 

第一個是直接呼叫,第二個是呼叫後立即執行的表達式,第三個是先執行了一條賦值語句,然後再呼叫返回的結果。賦值語句返回了一個函式,然後在全域環境下呼叫這個函式。

模仿塊級作用域

function outputNumber(count){ for(var i=0;i<count;i++){ console.log(i); } var i;// 只變量提升,到後面執行代碼步驟時候略過此 console.log(i); } outputNumber(3);// 0 1 2 3

JavaScript 不會告訴你是否多次宣告了同一個變數,遇到這種情況,它只會對後續的聲明視而不見(不過它會執行後續聲明中的變數初始化)。

匿名函式可以用來模仿塊級作用域(私有作用域),語法如下:

(function(){ //這裡是塊級作用域 })();

以上程式碼定義並立即呼叫了一個匿名函式,將函式聲明包含在一對圓括號中,表示它實際上是一個函式表達式。要將函式聲明轉化為函式表達式,就得靠這對圓括號。

function outputNumber(count){ (function(){ for(var i=0;i<count;i++){ console.log(i); } })(); console.log(i);// 報錯 } outputNumber(3);// 0 1 2

在 for 循環外邊加了一個私有作用域,在匿名函式中定義的任何變數都會在執行結束時被銷毀。在私有作用域中能訪問變數 count,是因為這個匿名函式是一個閉包,它能訪問包含作用域的所有變數。這種技術經常用在全域作用域中,用來限制向全域作用域中添加過多的變數和函式,同時也能減少閉包佔用記憶體的問題,因為沒有指向匿名函式的引用,只要函式執行完畢,就可以立即銷毀其作用域鏈了。

私有變數

嚴格來講,JavaScript 中沒有私有成員的概念,所有物件屬性都是公有的,不過有私有變數的概念。任何在函式中定義的變數,都可認為是私有變數,因為不能在函式外部訪問這些變數。私有變數包括函式的參數、局部變數、在函式內定義的其他函式。如果在函式內部創建一個閉包,那麼閉包透過自己的作用域也可以訪問這些變數。利用這一點創建用於訪問私有變數的公有方法,把有權訪問私有變數和私有函式的方法叫特權方法(privileged method)。

  • 兩種在自定義物件上創建特權方法的方式
  1. 在建構函式中定義特權方法
    function MyObject(){ //私有變量和私有函數 var privateVariable=10; function privateFunction(){ return false; } // 特權方法 this.publicMethod=function(){ privateVariable++; return privateFunction(); }; }
    new MyObject();

    這個模式在建構函式內部定義了所有私有變數和函式,又繼續創建了能夠訪問這些私有成員的特權方法。能在建構函式中定義特權方法,是因為特權方法作為閉包有權訪問在建構函式中定義的所有變數和函式。變數 privateVariable 和方法 privateFunction 只能透過特權方法 publicMethod 訪問。利用私有和特權成員,可以隱藏那些不應該被直接修改的資料。

    function Person(name){ this.getName=function(){ return name; }; this.setName=function(value){ name=value; }; } var p1=new Person("aa"); p1.getName();// "aa" var p2=new Person("bb"); p2.getName();// "bb" p1.getName();// "aa"

    這個方法定義了兩個特權方法,在 Person 建構函式外部沒有任何辦法直接訪問 name。由於這兩個方法是在建構函式內部定義的,它們作為閉包能透過作用域鏈訪問 name。私有變數 name 在每個 Person 實例都不相同,每次呼叫建構函式都會重新創建這兩個方法,p1.getName 和 p2.getName 是不同的函式,雖然呼叫的是記憶體中同一個 Person 函式。缺點是:在建構函式中定義特權方法要求你必須使用建構函式模式,而建構函式模式的缺點是針對每個實例都會創建同一組新方法。使用靜態私有變數來實現特權方法就可以避免這個問題。

  2. 靜態私有變數。透過在私有作用域中定義私有變數和函式,也可以創建特權方法。基本模式如下:
    (function(){ //私有變量和私有函數 var privateVariable=10; function privateFunction(){ return false; } //構造函數 MyObject=function(){}; //公有/特權方法 MyObject.prototype.publicMethod=function(){ privateVariable++; return privateFunction(); }; })();

    這個模式創建了個私有作用域,並在其中封裝了一個建構函式和相應方法。公有方法在原型上定義,體現了典型的原型模式。這種模式在定義建構函式時並未使用函式聲明,而是使用函式表達式;也沒有用 var 宣告 MyObject,就是想讓它成為一個全域變數,能夠在私有作用域之外被訪問,但嚴格模式下未經宣告的變數賦值會出錯,可以修改為:

    'use strict'; var MyObject; (function(){ //私有變量和私有函數 var privateVariable=10; function privateFunction(){ return false; } //構造函數 MyObject=function(){}; //公有/特權方法 MyObject.prototype.publicMethod=function(){ privateVariable++; return privateFunction(); }; })();

    這種模式與在建構函式中定義特權方法的主要區別就在於:私有變數和函式是由實例共享的,因為只呼叫(初始化)了一次父環境。由於特權方法是在原型上定義的,因此所有實例都使用同一個函式,而這個特權方法作為一個閉包總是保存著對包含作用域的引用。

    (function(){ var name=""; Person=function(value){ name=value; }; Person.prototype.getName=function(){ return name; }; Person.prototype.setName=function(value){ name=value; }; })(); var p1=new Person("aa"); p1.getName();// "aa" var p2=new Person("bb"); p2.getName();// "bb" p1.getName();// "bb"

    在這種模式下,變數 name 就成了一個靜態的、由所有實例共享的屬性。在一個實例上呼叫 setName() 會影響所有實例。以這種模式創建靜態私有變數會因為使用原型而增進程式碼復用,但每個實例都沒有自己的私有變數。多查找作用域鏈中的一個層次,會在一定程度上影響查找速度,這正是使用閉包和私有變數的一個不足之處。

  • 模塊模式:前面的模式用於為自定義型別創建私有變數和特權方法,而模塊模式則是為單例創建私有變數和特權方法。所謂單例(singleton)指的就是只有一個實例的物件,JavaScript 是以物件字面量的方式來創建單例物件的。模塊模式透過為單例添加私有變數和特權方法使其得到增強,語法如下:
    var singleton=function(){ //私有變量和私有函數 var privateVariable=10; function privateFunction(){ return false; } //特權/公有方法和屬性 return { publicProperty:true, publicMethod:function(){ privateVariable++; return privateFunction(); } } }();

    這個模式使用了一個回傳物件的匿名函式,把一個物件字面量作為函式返回,本質上這個物件字面量定義的是一個單例的公共介面。這種模式在需要對單例進行某些初始化、同時又需要維護其私有變數時非常有用。在 web 應用程式中,經常需要用一個單例來管理應用程式級的資訊,如果必須創建一個物件並以某些資料對它進行初始化,同時還要公開一些能夠訪問這些私有資料的方法,就可以使用模塊模式。

  • 增強的模塊模式:如果想讓單例是某種類型的實例,可以在返回物件之前加入對其增強的程式碼,同時添加某些屬性和方法加以增強。
    var singleton=function(){ //私有變量和私有函數 var privateVariable=10; function privateFunction(){ return false; } //創建對象 var obj=new CustomType(); //添加特權/公有屬性和方法 obj.publicProperty=true; obj.publicMethod=function(){ privateVariable++; return privateFunction(); } return obj; }();

閉包的作用總結:

  1. 使用閉包可以在 JavaScript 中模仿塊級作用域。創建並立即呼叫一個函式,既可以執行其中程式碼,又不會在記憶體中留下對該函式的引用,結果就是函式內部的所有變數都會被立即銷毀,除非將某些變數賦值給了包含作用域中的變數。
  2. 閉包還可用於在物件中創建私有變數。透過閉包實現公有方法,透過公有方法可以訪問在包含作用域中定義的變數,有權訪問私有變數的公有方法叫特權方法。可以使用建構函式模式、原型模式來實現自定義型別的特權方法,使用模塊模式、增強的模塊模式實現單例的特權方法。

參考:《JavaScript 高級程式設計》、深入解讀 JavaScript 面向物件程式設計實踐。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved