在 C/C++、Java、C# 這類傳統語言中,函數始終是「二等公民」。你只能用關鍵字把函數宣告出來再呼叫它;一旦想把函數當參數傳給別的函數、指派給區域變數,或者當成回傳值,就得靠函數指標(function pointer)、委派(delegate)這類機制繞一圈才行。
JavaScript 完全不是這套邏輯。函數在這裡是一等公民:除了宣告與呼叫,它還能像普通數值一樣被指派、被傳參、被回傳,這類函數被稱為第一級函數(First-class Function)。更特別的是,JavaScript 的函數同時還肩負「類的建構函數」角色,而它本身又是 Function 類別的實例。多重身分疊在一起,讓函數成為整門語言最關鍵的設計。
JavaScript 同樣遵循先宣告後使用的基本原則。函數名稱只能由字母、數字、底線與 $ 組成,且不能以數字開頭。最常見的兩種宣告寫法如下:
// 直接宣告一個具名函數
function myfunc(/* arguments */) {
}
// 把匿名函數指派給區域變數
var myfunc = function(/* arguments */) {
}
這兩種寫法看起來差不多,實際行為卻有關鍵差異。第一種是貨真價實的函數宣告(function declaration),無論它寫在呼叫之前、之後,甚至寫在永遠不會執行的位置(例如 return 之後、或恆為 false 的分支裡),整個作用域內都能存取到它。第二種嚴格說來不是宣告,而是函數表達式(function expression):在指派完成之前,這個函數無法被任何程式碼取用。也就是說,指派必須先於呼叫發生,否則就會拿到 TypeError: undefined is not a function。
myfunc1(); // 正常執行,myfunc1 是直接宣告的
function myfunc1() {
}
myfunc2(); // 拋出 TypeError: undefined is not a function
var myfunc2 = function() {
};
呼叫方式與傳統語言無異,一對括號即可:myfunc()。遞迴(recursive)也完全支援,直接或間接呼叫自己都行,經典的費氏數列就是很好的示範:
function fib(n) {
if (n == 1 || n == 2) {
return 1;
} else {
return fib(n - 2) + fib(n - 1);
}
}
另一個實用特性是可變長參數。函數體內天生有一個名為 arguments 的區域變數,它是類陣列(array-like)物件,收錄了呼叫時傳入的全部實參,並帶有表示個數的 length 屬性。
function test() {
alert(arguments.length);
}
test(1); // 1
test(1, 'a'); // 2
test(true, [], {}); // 3
靠著 arguments,你可以輕鬆做出類似 C 語言 printf 的可變參數效果,也能用來模擬方法多載。
JavaScript 允許宣告沒有名稱的函數,也就是匿名函數(Anonymous Function);也允許在函數內部再宣告函數,稱為嵌套函數(Nested Function),其作用域覆蓋整個父函數。
匿名函數因為不引入新名稱,不會污染上下文,同時又能自帶一層新的作用域,因此常被拿來隔離環境。瀏覽器裡有一個特殊的全域物件(global object)存放所有全域函數與變數,而實際專案往往同時載入多個第三方套件或 js 檔。一旦兩份程式碼各自宣告了同名的 log,後者會靜默覆蓋前者,不丟任何錯誤,等到後續呼叫時才莫名其妙出問題。
把整份腳本包進一個匿名函數並立即執行,是業界公認的解法,絕大多數開源庫都這麼做:
(function() {
function log(msg) {
console.log(msg);
}
// 其他程式碼
}());
外層那對小括號把函數宣告變成函數表達式,表達式的值是一個函數,緊接著的第二對括號則是立即呼叫它。log 的作用域被鎖在這個閉包內,外部完全看不到。若需要對外暴露介面,常見有三種做法:
var mylib = (function(global) {
function log(msg) {
console.log(msg);
}
log1 = log; // 法一:漏寫 var,log1 會變成全域變數(不建議)
global.log2 = log; // 法二:直接把屬性掛到全域物件上(建議)
return { // 法三:回傳一組介面物件,再指派給全域變數 mylib(建議)
log: log
};
}(window));
把函數當成參數或回傳值來用,就叫做高階函數。JavaScript 裡的函數天生都具備這個能力,這正是第一級函數的具體體現。
先看「函數作為參數」:
function negative(n) {
return -n; // 取相反數
}
function square(n) {
return n * n; // 取平方
}
function process(nums, callback) {
var result = [];
for (var i = 0, length = nums.length; i < length; i++) {
result[i] = callback(nums[i]); // 交給 callback 處理,收集回傳值
}
return result;
}
var nums = [-3, -2, -1, 0, 1, 2, 3, 4];
var n_neg = process(nums, negative);
// n_neg = [3, 2, 1, 0, -1, -2, -3, -4];
var n_square = process(nums, square);
// n_square = [9, 4, 1, 0, 1, 4, 9, 16];
process 完全把 callback 當黑箱看待:只負責餵參數、收結果,事先並不知道對方要幹什麼。直到迴圈真正跑到那一行,callback 才分別代表 negative 或 square。同一套流程,兩種行為,這就是回調帶來的彈性。
再看「函數作為回傳值」:
function generator() {
var i = 0;
return function() {
return i++;
};
}
var gen1 = generator(); // 取得一個自然數產生器
var gen2 = generator(); // 取得另一個獨立的產生器
var r1 = gen1(); // r1 = 0
var r2 = gen1(); // r2 = 1
var r3 = gen2(); // r3 = 0
var r4 = gen2(); // r4 = 1
每次呼叫 generator 都會回傳一個新的匿名函數,被呼叫時依序吐出自然數。而 generator 內部的變數 i 會隨著每次呼叫自增,並在函數返回後依然存活——這就是閉包。
閉包並不是新概念,許多函數式語言早有實作。在 JavaScript 中,只要你在內層函數裡讀寫外層函數作用域中的變數,你就在使用閉包。有個流傳很廣的類比:類是「帶著函數的資料」,閉包則是「帶著資料的函數」。
閉包捕獲的變數有個關鍵特性:它們不會在父函數返回時被釋放,而是跟著閉包的生命週期一起結束。回到上面的例子,gen1 與 gen2 各自持有獨立的 i,互不干擾;只要這兩個變數還沒被垃圾回收器清掉,它們的 i 就一直留在記憶體裡。
正因為閉包在 JavaScript 中幾乎無所不在,這個特性在帶來便利的同時,也容易埋下類似記憶體洩漏的隱患:
var elem = document.getElementById('test');
elem.addEventListener('click', function() {
alert('You clicked ' + elem.tagName);
});
這段程式把匿名函數註冊成 DOM 節點的 click 處理器,而函數內又引用了 DOM 物件 elem,閉包於焉成形,接著就出現循環引用:DOM → 閉包 → DOM → 閉包……DOM 要等閉包釋放才能釋放,閉包作為 DOM 的事件處理器又要等 DOM 釋放才能釋放。結果是即使你把節點從 DOM 樹上移除,兩者都不會被回收。
解法很簡單,改用 this 就好:
var elem = document.getElementById('test');
elem.addEventListener('click', function() {
alert('You clicked ' + this.tagName); // 不再直接引用 elem
});
在 DOM 事件處理器中,this 指向觸發事件的元素本身。這樣寫之後,執行環境不再認為函數用到了外層變數,閉包也就不會形成。閉包造成的類似問題還有很多,寫程式時多留一份心,就能避開大部分坑。
由於函數同時扮演建構函數的角色,只要宣告一個函數,就能用 new 建立實例。
function Person(name) {
this.name = name;
this.toString = function() {
return 'Hello, ' + this.name + '!';
};
}
var p = new Person('Ghostheaven');
alert(p); // Hello, Ghostheaven!
此時 this 指向新建立的實例,可以直接掛上屬性與方法。這裡想特別提醒的是建構函數的「回傳值」問題:
function MyClass(name) {
this.name = name;
return name; // 建構函數裡的回傳值?
}
var obj1 = new MyClass('foo');
var obj2 = MyClass('foo');
var obj3 = new MyClass({});
var obj4 = MyClass({});
實際結果是:
obj1 = MyClass 物件
obj2 = 'foo'
obj3 = {}
obj4 = {}
當建構函數回傳的是基本型別時,new 會忽略它並照舊回傳新實例;但一旦回傳物件,這個物件就會取代原本的實例成為最終結果,行為立刻變得難以預期。結論很樸素:不要在建構函數裡寫帶值回傳(空的 return 無妨)。
JavaScript 執行環境內建了一個名為 Function 的類別,用 function 關鍵字宣告函數,其實就是建立 Function 物件的一種語法糖。所有函數都繼承了 Function 的方法,例如 call、apply、bind,用 instanceof 一驗便知。
既然 Function 是個類別,理論上就能用 new 動態造出函數。它的語法如下:
new Function ([arg1[, arg2[, ... argN]],] functionBody)
其中 arg1 到 argN 是代表參數名的字串,functionBody 則是函數主體的字串。參數個數可多可少,建構子會把最後一個參數當成函數體,前面全部當成參數處理。
var func1 = new Function('name', 'return "Hello, " + name + "!";');
func1('Ghostheaven'); // Hello, Ghostheaven!
用這種方式產生的函數,和用 function 關鍵字宣告的完全等價。至於為什麼需要它?「存在必有理由」——它能讓你在執行期動態組出函數邏輯,可以替代 eval 的部分用途,而且不會污染當前環境(在嚴格模式下,eval 本身也受到大幅限制,同樣能保住環境乾淨)。
多數語言不允許重複宣告同名函數,否則直接語法錯誤。JavaScript 不但允許,函數還能替換掉自己:
function selfUpdate() {
window.selfUpdate = function() {
alert('second run!');
};
alert('first run!');
}
selfUpdate(); // first run!
selfUpdate(); // second run!
第一次呼叫時,函數順手把全域的 selfUpdate 換成新實作,於是第二次呼叫走的就是另一段邏輯。這個技巧很適合「只需執行一次的初始化」,跑完之後自動換成後續行為。
JavaScript 的函數威力強大,優雅地解決了大量問題,但也附帶了不少副作用。本文第三節那些「妖怪級」用法多屬鮮為人知的偏門技巧,除非確有必要,否則盡量別在團隊專案中採用,不然程式碼可讀性會大幅下降,反而拖累協作效率。
把基礎紮實練好、把閉包與作用域的規則想清楚,比追逐奇技淫巧重要得多。若文中有疏漏之處,也歡迎先進指教,一起進步。