DIV CSS 佈局教程網

JavaScript 進階筆記:函數表達式、遞迴與閉包完整解析
編輯:關於JavaScript     

定義函數有兩種方式:函數宣告與函數表達式。兩者看起來相似,行為卻有關鍵差異,而閉包與遞迴的諸多陷阱也正源自這裡。

一、函數宣告

 function functionName(arg0, arg1, arg2){
  // 函數體
}

結構很直白:function 關鍵字、函數名稱,然後是參數與函數體。

Firefox、Safari、Chrome 與 Opera 為函數額外實作了一個非標準的 name 屬性,可以讀回函數的名字,其值永遠等於 function 後頭的識別字。

 //只在 FF、Safari、Chrome 和 Opera 有效
alert(functionName.name); // functionName

函數宣告最重要的特性是宣告提升(hoisting):執行程式碼之前,引擎會先讀取所有函數宣告。這意味著你可以在呼叫語句「之前」還沒寫到函數定義,程式依然正常:

 sayHi();
function sayHi(){
  alert("Hi!");
}

這段不會拋錯,因為函數宣告已被提前讀入。

二、函數表達式

 var functionName = function(arg0, arg1, arg2){
  // 函數體
};

這形式看起來就是普通的變數指派:建立一個函數並賦給變數。由於 function 後頭沒有識別字,這種函數稱為匿名函數(anonymous function),有時也叫拉姆達函數。匿名函數的 name 屬性是空字串。

函數表達式與其他表達式一樣,使用前必須先完成賦值。以下程式會出錯:

 syaHi(); // Uncaught ReferenceError: syaHi is not defined
var sayHi = function(){
  alert("Hi!");
};

原因就在於表達式不會被提升,只有宣告會。

另外,別把函數宣告寫進條件分支裡,這在 ECMAScript 中屬於無效語法。引擎會試圖修正,但各家瀏覽器的修正方式不同,結果難以預期:

 //不要這樣做
if(condition){
  function sayHi(){ alert("Hi!"); }
}else{
  function sayHi(){ alert("Yo!"); }
}

改用函數表達式就完全沒問題:

 //可以這樣做
var sayHi;
if(condition){
  sayHi = function(){ alert("Hi!"); }
}else{
  sayHi = function(){ alert("Yo!"); }
}

既然函數可以賦值給變數,自然也就能當成其他函數的返回值。

 function creatComparisonFunction(propertyName){
  return function(object1, object2){
    var value1 = object1[propertyName];
    var value2 = object2[propertyName];
    if(value1 < value2){
      return -1;
    }else if(value1 > value2){
      return 1;
    }else{
      return 0;
    }
  };
}

creatComparisonFunction() 回傳一個匿名函數。它被返回之後可能被指派給變數或以其他方式呼叫,但在函數「內部」它始終是匿名的。當函數被當值使用時,匿名函數是最自然的選擇。

三、遞迴

遞迴函數是指透過名字呼叫自己來建構的函數。最經典的例子莫過於階乘:

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

但下面這段程式卻會讓它出錯:

 var anotherFactorial = factorial;
factorial = null;
alert(anotherFactorial(4)); // Uncaught TypeError: factorial is not a function

這裡先把 factorial() 存進 anotherFactorial,接著把 factorial 設為 null。此時呼叫 anotherFactorial(),函數體內卻仍要執行 factorial(),而它已經不再是函數了,於是報錯。

解法是使用 arguments.callee——一個指向「正在執行的函數本身」的指標:

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

寫遞迴時,arguments.callee 總比函數名保險,因為無論函數被怎麼重新指派都不會出問題。

但要注意:嚴格模式下不能透過腳本存取 arguments.callee。此時改用有名函數表達式即可達到相同效果:

 var factorial = (function f(num){
  if(num <= 1){
    return 1;
  }else{
    return num * f(num-1);
  }
});
console.log(factorial(4)); // 24

這個寫法在嚴格與非嚴格模式下都成立,是現代較推薦的做法。

四、閉包

閉包指的是有權存取另一個函數作用域中變數的函數。建立閉包最常見的方式,就是在函數內部再定義一個函數。

回到前面的比較器:

 function creatComparisonFunction(propertyName){
  return function(object1, object2){
    var value1 = object1[propertyName]; // 存取外部函數的 propertyName
    var value2 = object2[propertyName]; // 存取外部函數的 propertyName
    if(value1 < value2){
      return -1;
    }else if(value1 > value2){
      return 1;
    }else{
      return 0;
    }
  };
}

內部匿名函數存取了外部函數的變數 propertyName。即使這個內部函數被返回、並在別處被呼叫,它仍然讀得到該變數——因為內部函數的作用域鏈中包含了 creatComparisonFunction() 的作用域。

作用域鏈的運作

函數被呼叫時,會建立一個執行環境(execution context)與對應的作用域鏈,並以 arguments 和其他命名參數初始化函數的活動物件(activation object)。在作用域鏈中,外部函數的活動物件永遠排第二位,再外一層排第三位,直到鏈的終點——全域執行環境。

 function compare(value1, value2){
  if(value1 < value2){
    return -1;
  }else if(value1 > value2){
    return 1;
  }else{
    return 0;
  }
}
var result = compare(5, 10);
console.log(result); // -1

先定義 compare(),再在全域呼叫它。呼叫時建立一個含 arguments、value1、value2 的活動物件;而全域執行環境的變數物件(含 result 與 compare)則位於作用域鏈第二位。

每個執行環境都有一個代表變數的物件——變數物件。全域的變數物件恆常存在,而函數這種區域環境的變數物件只在執行期間存在。建立 compare() 時,會預先建立一條含全域變數物件的作用域鏈,存於內部的 [[Scope]] 屬性中;呼叫時則複製 [[Scope]] 的內容來建構執行環境的作用域鏈,接著把新的活動物件推到鏈的前端。

所以本質上,作用域鏈只是一份指向變數物件的指標清單,它引用但不實際持有那些物件。

一般來說,函數執行完畢後,區域活動物件就會被銷毀,記憶體中只留全域作用域。但閉包是個例外:在另一函數內部定義的函數,會把包含函數(外部函數)的活動物件一併加進自己的作用域。

 var compare = creatComparisonFunction("name");
var result = compare({name:"Nicholas"}, {name:"Greg"});


當 createComparisonFunction() 返回後,它的執行環境作用域會被銷毀,但活動物件仍留在記憶體中,直到匿名函數也被銷毀為止。

 //創建函數
var compare = creatComparisonFunction("name");
//調用函數
var result = compare({name:"Nicholas"}, {name:"Greg"});
//解除對匿名函數的引用(以便釋放內存)
compareNames = null;

把引用設為 null,等於通知垃圾回收機制可以清除它。隨著匿名函數的作用域鏈被銷毀,其他非全域作用域也就能安全釋放了。

由於閉包會攜帶包含函數的整個作用域,它比其他函數佔用更多記憶體。過度使用閉包會導致記憶體佔用偏高,需審慎評估。

閉包與變數:一個經典陷阱

作用域鏈這種配置有個值得注意的副作用:閉包只能取得包含函數中任何變數的最後一個值,因為閉包保存的是整個變數物件,而不是某個特定時刻的快照。

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

表面上每個函數都該回傳自己的索引,實際上它們全部回傳 10。原因就在於:每個函數的作用域鏈都保存著同一個 createFunctions() 活動物件,因此參照的是同一個變數 i。當 createFunctions() 返回時,i 已經是 10。

解法是再包一層匿名函數,強迫閉包行為符合預期:

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

這裡沒有直接把閉包指派給陣列,而是先定義一個匿名函數並立即執行,把結果存入陣列。該匿名函數有個參數 num,就是最終要回傳的值。呼叫時傳入變數 i,由於參數是按值傳遞,i 的當前值會被複製給 num。接著在這個匿名函數內部建立並回傳一個存取 num 的閉包。如此一来,陣列中每個函數都有自己的 num 副本,自然能回傳各自不同的值。

關於 this 物件

this 是在執行期依呼叫方式綁定的:在全域函數中 this 等於 window;當函數作為某物件的方法被呼叫時,this 等於該物件。但匿名函數的執行環境具有全域性,因此其 this 通常指向 window。

 var name = "the window";
var object = {
  name: "my object",
  getNameFunc: function(){
    return function(){
      return this.name;
    };
  }
};
alert(object.getNameFunc()()); // the window(非嚴格模式下)

每個函數被呼叫時都會自動取得兩個特殊變數:this 與 arguments。內部函數搜尋這兩個變數時,只會搜到自己的活動物件為止,因此永遠不可能直接存取外部函數的這兩個變數。

解法是把外部作用域的 this 存進一個閉包讀得到的變數:

 var name = "the window";
var object = {
  name: "my object",
  getNameFunc: function(){
    var that = this;
    return function(){
      return that.name;
    };
  }
};
alert(object.getNameFunc()()); // my object

在定義匿名函數之前,先把 this 指派給 that。因為 that 是在包含函數中刻意宣告的變數,閉包自然讀得到;即使在函數返回之後,that 仍參照著 object,所以 object.getNameFunc()() 會回傳 my object。

arguments 也有同樣的問題,若要存取它,必須先把參照存到另一個閉包讀得到的變數裡。

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

最後一行先執行了一條指派語句,再呼叫指派結果。因為指派表達式的值就是函數本身,this 的綁定無法維持,於是回退成全域的 "the window"。

記憶體洩漏

由於 IE9 之前的版本對 JScript 物件與 COM 物件使用不同的垃圾回收機制,閉包在這些舊版 IE 中會引發特殊問題。具體而言,若閉包的作用域鏈中保存著一個 HTML 元素,該元素就無法被銷毀。

 function assignHandlet(){
  var element = document.getElementById("someElement");
  element.onclick = function(){
    alert(element.id);
  };
}

這裡建立了一個作為 element 事件處理程序的閉包,同時形成循環參照:匿名函數保存了對 assignHandler() 活動物件的參照,導致 element 的參照數無法遞減。只要匿名函數存在,element 的參照數至少是 1,佔用的記憶體永遠不會回收。稍微改寫即可解決:

 function assignHandlet(){
  var element = document.getElementById("someElement");
  var id = element.id;
  element.onclick = function(){
    alert(id);
  };
  element = null;
}

這裡把 element.id 複製到一個變數,閉包改為參照該變數,循環參照就消除了。

特別提醒:閉包會參照包含函數的整個活動物件,而其中含有 element。即使閉包不直接參照 element,包含函數的活動物件仍會保留一份參照。因此有必要把 element 設為 null,才能解除對 DOM 物件的參照、順利回收記憶體。

五、重點回顧

在 JavaScript 中,函數表達式是很有用的技術:不必替函數命名,因而能實現動態程式設計。匿名函數(拉姆達函數)是運用函數的強力方式,重點如下:

  • 函數表達式不同於函數宣告。宣告要求有名稱,表達式則不需要;沒有名字的函數表達式就是匿名函數。
  • 當無法確定如何參照函數時,遞迴會變得複雜;遞迴函數應使用 arguments.callee 遞迴呼叫自身,而非函數名——函數名可能改變。在嚴格模式下則改用有名函數表達式。
  • 在函數內部定義其他函數時,就建立了閉包。閉包有權存取包含函數內部的所有變數。
  • 後台執行環境中,閉包的作用域鏈包含自身作用域、包含函數作用域與全域作用域。通常函數作用域及其變數會在執行結束後銷毀;但當函數回傳了一個閉包,該作用域會一直留在記憶體中,直到閉包不存在為止。
  • 利用閉包可以在 JavaScript 中模仿區塊級作用域(語言本身沒有這個概念)。要點是建立並立即呼叫一個函數,這樣既能執行其中程式碼,又不會在記憶體中留下對該函數的參照;結果是函數內部的變數會立即銷毀——除非被指派給外部作用域的變數。
  • 閉包還能用於在物件中建立私有變數。即使 JavaScript 沒有正式的私有屬性概念,也能透過閉包實作公有方法來存取包含作用域中定義的變數;這種能存取私有變數的公有方法稱為特權方法。自訂型別可用建構函數模式或原型模式實作特權方法,單例則可用模組模式或增強的模組模式。

函數表達式與閉包都是極其有用的特性,能實現大量進階功能。但也因為建立閉包必須維護額外的作用域,過度使用可能佔用大量記憶體,使用時請權衡取捨。

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