DIV CSS 佈局教程網

JavaScript 匿名函式與閉包完整解說
編輯:JavaScript綜合知識     

匿名函式與閉包是 JavaScript 最基礎也最容易混淆的兩個概念。前者是「沒有名字的函式」,後者是「能存取另一個函式作用域中變數的函式」。本文從定義出發,一路談到 this 指向、迴圈陷阱、塊級作用域、私有變數與模組模式。

一、匿名函式

// 具名函式
function box() {
  return 'Lee';
}
box();   // => 'Lee'

// 匿名函式:單獨寫會語法錯誤,因為需要一個名稱才能被呼叫
function() { return 'Lee'; }

// 透過「立即呼叫」執行
(function(name) {
  console.log(name);
})("Lee");

// 賦值給變數
var box = function() {
  return 'Lee';
};
console.log(box());

// 函式裡回傳匿名函式(這就產生了閉包)
function box() {
  return function(name) {
    return name;
  };
}
console.log(box()("Lee"));

「() 表示執行函式」是關鍵。當你寫 (function(){...})() 時,外層括號讓引擎把它當成表達式,後面的 () 才會真正呼叫它。

二、閉包

閉包:有權存取另一個函式作用域中變數的函式。最常見的建立方式,是在一個函式內部定義另一個函式,再透過它把內層的局部變數暴露出去。

function box() {
  var user = 'Lee';
  return function() {      // 這個匿名函式就是閉包
    return user;
  };
}

console.log(box()());      // => 'Lee',連續呼叫兩次
var b = box();
console.log(b());          // => 'Lee',另一種寫法

閉包的優點:避免全域變數

全域變數會污染整個應用程式的命名空間,任何模組都能改動它,是災難的來源。閉包讓狀態被封裝在局部作用域中,只透過你開放的介面存取。

閉包能保存狀態

// 用全域變數累加
var age = 100;
function box() { age++; }
box(); console.log(age);   // 101
box(); console.log(age);   // 102

// 用局部變數:無法累加
function box() {
  var age = 100;
  age++;
  return age;
}
console.log(box());        // 101
console.log(box());        // 101,每次呼叫 age 都被重新初始化

// 用閉包:可以累加
function box() {
  var age = 100;
  return function() {
    age++;
    return age;
  };
}
var b = box();
console.log(b());          // 101
console.log(b());          // 102,age 被保留了下來

差別在於:普通函式執行完畢,其活動物件(activation object)就會被回收;但當它回傳了一個閉包,該作用域必須持續存在,因為閉包還引用著它。

閉包的代價:記憶體

由於閉包所引用的作用域不會立刻被回收,過度使用會佔用較多記憶體,也可能造成效能下降。若確實不再需要,把引用解除即可讓資源釋放。

三、迴圈中的閉包陷阱

作用域鏈的機制導致一個經典問題:迴圈裡建立的匿名函式,取到的變數都是迴圈結束後的最終值。

function box() {
  var arr = [];
  for (var i = 0; i < 5; i++) {
    arr[i] = function() { return i; };   // 存的是函式,還沒執行
  }
  return arr;
}

var b = box();
b.forEach(function(fn) { console.log(fn()); });   // 5 5 5 5 5

因為 var 沒有塊級作用域,迴圈結束時 i 已成為 5,五個閉包共用同一個 i。

解法一:讓匿名函式立即執行,把值「凍結」下來

function box() {
  var arr = [];
  for (var i = 0; i < 5; i++) {
    arr[i] = (function(num) {
      return num;         // 此時回傳的是數值,不是函式
    })(i);                // 立即執行並傳入當下的 i
  }
  return arr;
}
console.log(box());       // [0, 1, 2, 3, 4]

解法二:立即執行的外層函式再回傳一個閉包

function box() {
  var arr = [];
  for (var i = 0; i < 5; i++) {
    arr[i] = (function(num) {
      return function() { return num; };   // 回傳函式
    })(i);
  }
  return arr;
}
box().forEach(function(fn) { console.log(fn()); });   // 0 1 2 3 4

兩種解法的共同點:透過傳值呼叫,為每一次迭代建立獨立的作用域。傳入的 i 是按值傳遞的副本,因此各自保留。

最簡潔的解法:用 let

for (let i = 0; i < 5; i++) {
  arr[i] = function() { return i; };
}
arr.forEach(fn => console.log(fn()));   // 0 1 2 3 4

let 每次迭代都會建立新的綁定,一行解決,現在應該優先採用。

四、閉包中的 this

this 是在執行期依呼叫方式綁定的,而不是依定義位置。閉包並不屬於建立它的那個物件的屬性或方法,因此其中的 this 會指向全域物件:

var user = 'Window';

var obj = {
  user: 'Object',
  getUserFunction: function() {
    return function() {
      return this.user;      // 這個閉包不屬於 obj,this 指向 window
    };
  }
};

console.log(obj.getUserFunction()());       // => 'Window'

// 解法一:用 call 強制指定
console.log(obj.getUserFunction().call(obj));   // => 'Object'

// 解法二:在上一層作用域先把 this 存起來
var obj2 = {
  user: 'Object',
  getUserFunction: function() {
    var that = this;         // that 指向 obj2
    return function() {
      return that.user;
    };
  }
};
console.log(obj2.getUserFunction()());      // => 'Object'

箭頭函式沒有自己的 this,會沿用外層的值,因此這個問題在它身上不會發生:

getUserFunction: function() {
  return () => this.user;    // 直接拿到 obj 的 this
}

五、模仿塊級作用域

JavaScript(ES6 之前)沒有塊級作用域的概念,意味著在 for 或 if 區塊中用 var 宣告的變數,實際上是屬於包含它的函式,離開區塊後依然存在:

function box(count) {
  for (var i = 0; i < count; i++) {}
  console.log(i);    // => 2,i 並未因為離開 for 而失效
}
box(2);

// 就算重新宣告也不會覆蓋
function box2(count) {
  for (var i = 0; i < count; i++) {}
  var i;
  console.log(i);    // => 2
}

JavaScript 不會警告你重複宣告同一個變數,它只會對後續的宣告視而不見(若有初始化賦值則仍會執行)。

用立即呼叫的匿名函式製造私有作用域

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

把函式宣告包在一對小括號中,表示它其實是一個函式表達式,因此可以立即呼叫。改寫上面的例子:

function box(count) {
  (function() {
    for (var i = 0; i < count; i++) {}
  })();
  console.log(i);    // 報錯:i 無法存取,已隨私有作用域結束而銷毀
}
box(2);

這種技術常用於全域作用域,用來限制往全域物件中添加過多的變數與函式,避免命名衝突。因為沒有外部引用指向該匿名函式,函式執行完畢後其作用域鏈會立刻被銷毀,也就不會佔用額外記憶體。

(function() {
  var box = [1, 2, 3, 4];
  console.log(box);
})();
console.log(box);    // => ReferenceError: box is not defined

六、私有變數

JavaScript 沒有私有屬性的概念,所有屬性都是公用的。但有私有變數:任何在函式中定義的變數,外部都無法存取。這些包含函式的參數、局部變數,以及在函式內部定義的其他函式。

function box() {
  var age = 100;       // 私有變數,外部無法存取
}

透過在內部建立閉包,就能開放出存取這些變數的公用方法,稱為特權方法:

function Box() {
  var age = 100;                 // 私有變數
  function run() {               // 私有函式
    return '運行中...';
  }
  this.get = function() {        // 對外的特權方法
    return age + run();
  };
}

var box = new Box();
console.log(box.get());

也可以透過建構子傳參來操作私有變數:

function Person(name) {
  var user = name;
  this.getUser = function() { return user; };
  this.setUser = function(name) { user = name; };
}

var p = new Person('Lee');
console.log(p.getUser());        // => 'Lee'
p.setUser('Jack');
console.log(p.getUser());        // => 'Jack'

缺點是:每個實例都會建立一份相同的新方法,造成記憶體浪費。改用靜態私有變數搭配 prototype 可以避免這個問題。

七、靜態私有變數

在私有作用域中定義變數,並把方法掛到 prototype 上,所有實例就能共用同一份方法與同一份私有狀態:

(function() {
  var age = 100;                 // 靜態私有變數,所有實例共用

  function run() {
    return '運行中...';
  }

  Box = function() {};           // 注意:故意不加 var,讓它成為全域變數
  Box.prototype.go = function() {
    return age + run();
  };
})();

var box = new Box();
console.log(box.go());           // => '100運行中...'

這裡有個刻意安排:用 Box = function(){} 而非 function Box(){},且不加 var。未經宣告就初始化的變數會成為全域變數,因此 Box 能在私有作用域之外被存取。若用函式宣告定義,它就會變成私有的,外部拿不到。

(function() {
  var user = "";
  Person = function(value) {     // Person 是全域變數
    user = value;                // 建構子有權存取私有變數
  };
  Person.prototype.getUser = function() { return user; };
  Person.prototype.setUser = function(value) { user = value; };
})();

var person = new Person();
person.setUser('Lee');
console.log(person.getUser());   // => 'Lee'

因為方法掛在 prototype 上而被子孫共用,user 就成了靜態屬性——即在不同物件之間共享的屬性。這也意味著所有 Person 實例會共用同一份姓名,實務上要依需求斟酌是否合適。

八、模組模式

若必須建立一個物件、以某些資料將它初始化,同時又要公開一些能存取這些私有資料的方法,就可以用模組模式。以字面量定義的單例物件特別適合:

var box = function() {
  var age = 100;                 // 私有

  function run() {               // 私有函式
    return '運行中...';
  }

  return {                       // 只公開需要公開的介面
    go: function() {
      return age + run();        // 公有方法有權存取私有成員
    }
  };
}();                             // 注意結尾的 (),立即執行

console.log(box.go());

也可以先建立物件再回傳,效果相同:

var box = function() {
  var age = 100;
  function run() { return '運行中...'; }
  var obj = {
    go: function() { return age + run(); }
  };
  return obj;
}();

字面量的物件宣告在設計模式中可視為一種單例模式——永遠維持只有一個實例。這種模式在需要對單例做初始化、又要維護私有變數時非常有用。

增強的模組模式:回傳自訂物件

function Desk() {}

var box = function() {
  var age = 100;
  function run() { return '運行中...'; }

  var desk = new Desk();
  desk.go = function() { return age + run(); };
  return desk;
}();

console.log(box.go());           // => '100運行中...'

差別只在最後回傳的是自訂型別的實例,而非字面量物件,因此能同時享有 instanceof 判斷與私有狀態。

九、重點整理

函式表達式

函式表達式不同於函式宣告:後者必須有名稱,前者不需要。沒有名字的函式表達式就是匿名函式。使用函式表達式可以無須命名而實現動態編程。

閉包

在函式內部定義其他函式時,就產生了閉包。閉包有權存取包含函式內部的所有變數。其原理是:

  • 閉包的作用域鏈包含自己的作用域、包含函式的作用域,以及全域作用域。
  • 一般情況下,函式的作用域與其所有變數會在函式執行完畢後被銷毀。
  • 但當函式回傳了一個閉包,該作用域會持續保存在記憶體中,直到閉包不存在為止。

塊級作用域

用閉包可以在 ES6 之前模仿塊級作用域。要點是:

  • 建立並立即呼叫一個函式,既能執行其中程式碼,又不會在記憶體中留下對該函式的引用。
  • 結果是函式內部的所有變數都會立即被銷毀——除非你把某些變數指派給了外部作用域的變數。

私有變數

閉包還能用於在物件中建立私有變數。要點是:

  • 即使 JavaScript 沒有真正的私有屬性概念,仍可用閉包實作公有方法,並透過它存取包含作用域中定義的變數。
  • 可以使用建構子模式或原型模式實作自訂型別的特權方法,也可以用模組模式實作單例的特權方法。

現代補充:# 私有欄位

ES2022 起,JavaScript 有了原生的私有欄位語法,不再需要靠閉包繞路:

class Box {
  #age = 100;                    // 真正的私有欄位

  #run() {                       // 私有方法
    return '運行中...';
  }

  get status() {
    return this.#age + this.#run();
  }
}

const b = new Box();
console.log(b.status);           // => '100運行中...'
console.log(b.#age);             // 語法錯誤,外部無法存取

它比閉包模式更直觀、效能更好(方法在原型上共享),也不會干擾 for...in。新專案請優先採用 # 語法;理解閉包仍然重要,因為它是無框架 JavaScript 與眾多套件設計的基礎。

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