匿名函式與閉包是 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 是按值傳遞的副本,因此各自保留。
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 會指向全域物件:
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 之前模仿塊級作用域。要點是:
閉包還能用於在物件中建立私有變數。要點是:
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 與眾多套件設計的基礎。