函式是 JavaScript 的一等物件。想真正學好這語言,就必須把函式吃透。這篇文章整理兩塊最容易含糊帶過的內容:參數的各種行為,以及閉包的形成機制與實用場景。
定義函式時,我們常需要傳入額外的資料,不同的外部輸入得到不同結果,這些外部資料就是參數。
function keith(a){ return a + a; }
console.log(keith(3)); // 6
JavaScript 規範允許呼叫時省略實際參數,這點與多數語言不同。
function keith(a, b, c) { return a; }
console.log(keith(1, 2, 3)); // 1
console.log(keith(1)); // 1
console.log(keith()); // undefined
不管傳入幾個參數都不會報錯,被省略的參數值就是 undefined。要注意函式的 length 屬性回傳的是形式參數個數,與實際傳入的數量無關。
(實際參數:呼叫時傳入的。形式參數:定義時宣告的。)
不過,你無法只省略前面的參數而保留後面的。若一定要跳過前面的位置,只能顯式傳入 undefined:
function keith(a, b) { return a; }
console.log(keith(, 1)); // SyntaxError
console.log(keith(undefined, 2)); // undefined
JavaScript 中參數的預設值是 undefined。若需要不同的預設值,傳統做法是在函式主體內檢查:
function keith(a, b) {
b = (typeof b !== 'undefined') ? b : 1;
return a * b;
}
console.log(keith(15)); // 15
console.log(keith(15, 2)); // 30
從 ECMAScript 6 開始支援預設參數語法,函式體內的檢查就可以省掉了:
function keith(a, b = 1) { return a * b; }
console.log(keith(15)); // 15
console.log(keith(15, 2)); // 30
傳值傳遞:當參數是原始型別(字串、數值、布林值)時採用。函式體內修改參數,不影響外部。
var a = 1;
function keith(num) { num = 5; }
keith(a);
console.log(a); // 1
因為函式內部拿到的是原始值的複本,怎麼改都不影響外部。
傳址傳遞:當參數是複合型別(陣列、物件、其他函式)時採用。傳入的是位址,因此函式內部修改會影響外部。
var arr = [2, 5];
function keith(Arr) { Arr[0] = 3; }
keith(arr);
console.log(arr[0]); // 3
但有一個重要例外:如果函式內部替換掉整個參數物件,而非修改它的屬性,就不會影響外部值。
var arr = [2, 3, 5];
function keith(Arr) { Arr = [1, 2, 3]; }
keith(arr);
console.log(arr); // [2, 3, 5]
原因是形式參數 Arr 與實際參數 arr 之間只是一層賦值關係,重新賦值 Arr 等同於讓它指向新的物件,原本 arr 的參照並未改變。
若有同名參數,取最後出現的那個值;若最後一個未提供值,則結果為 undefined。
function keith(a, a) { return a; }
console.log(keith(1, 3)); // 3
console.log(keith(1)); // undefined
想存取第一個同名參數,得靠 arguments 物件:
function keith(a, a) { return arguments[0]; }
console.log(keith(2)); // 2
JavaScript 中每個函式內部都能存取一個特殊變數 arguments,它維護著所有傳入該函式的參數清單。arguments[0] 是第一個參數,arguments[1] 是第二個,依此類推。這個物件只在函式體內部可用。
function keith(a, b, c) {
console.log(arguments[0]); // 1
console.log(arguments[2]); // 3
console.log(arguments.length); // 4
}
keith(1, 2, 3, 4);
arguments 不是陣列
雖然它有 length 屬性,語法上看起來像陣列,但它並不繼承自 Array.prototype,本質上是一個「類陣列物件」。因此你無法對它使用 push、pop、slice 等標準陣列方法,只能用 length。
若需要真正轉成陣列,常見寫法是:
var arr = Array.prototype.slice.call(arguments);
理解閉包之前,得先分清全域作用域與區域作用域:函式內部可以存取全域變數,但函式外部無法存取函式內部定義的區域變數。
var a = 1;
function keith() { var b = 2; return a; }
console.log(keith()); // 1
console.log(b); // ReferenceError: b is not defined
想取得函式內部的區域變數,唯一的辦法是在函式內部再定義一個函式:
function keith(){
var a = 1;
function rascal(){ return a; }
return rascal;
}
var result = keith();
console.log(result()); // 1
也可以直接回傳匿名函式,效果相同:
function keith(){
var a = 1;
return function(){ return a; };
}
var result = keith();
console.log(result()); // 1
這裡起作用的是 JavaScript 特有的「鏈式作用域」結構:子物件會一層層向上搜尋所有父物件的變數。因此父物件的所有變數對子物件都是可見的,反之則不然。keith 回傳的 rascal 能讀取 keith 的內部變數,我們就在外部取得了 keith 的內部變數。
閉包指的就是 rascal 這樣的函式——能讀取其他函式內部變數的函式。由於 JavaScript 中只有函式內部的子函式才能讀取內部變數,閉包也可以簡單理解為「定義在函式內部的函式」。
閉包最大的特點是它能「記住」誕生的環境。rascal 記住了它的誕生源 keith,所以能從 keith 取得內部變數。反過來說,閉包讓它的誕生環境得以持續存在:
function keith(num) {
return function() { return num++; };
}
var result = keith(2);
console.log(result()); // 2
console.log(result()); // 3
console.log(result()); // 4
參數 num 相當於 keith 內部的區域變數。透過閉包,num 的狀態被保留下來,每次呼叫都建立在前一次的結果上。這也說明閉包讓函式的內部環境一直存在於記憶體中。
閉包的三個特點:
閉包的另一個實用場景是封裝私有屬性與私有方法:
function Keith(name) {
var age;
function setAge(n) { age = n; }
function getAge() { return age; }
return { name: name, setAge: setAge, getAge: getAge };
}
var person = Keith('keith');
person.setAge(21);
console.log(person.name); // 'keith'
console.log(person.getAge()); // 21
age 被藏在閉包裡,外部只能透過 setAge 與 getAge 操作,無法直接存取。這是 JavaScript 在 class 語法普及之前實作私有的標準手法。
IIFE 通常只用於匿名函式,目的有兩個:一是免去了命名,避免污染全域變數;二是 IIFE 內部形成獨立作用域,可以封裝外部讀不到的私有變數。
循環中的閉包陷阱
最常見的閉包錯誤出現在迴圈中。假設我們希望在每次迴圈裡印出序號:
for(var i = 0; i < 10; i++){
setTimeout(function(){ console.log(i); }, 1000)
}
結果並不會如預期印出 0 到 9,而是連續印出十次 10。原因是匿名函式執行時仍持有對全域變數 i 的參照,等 1 秒後它真的被執行時,for 迴圈早已結束,i 的值已被改成 10。
用 IIFE 在每次迴圈中建立 i 的複本即可解決:
for(var i = 0; i < 10; i++) {
(function(e) {
setTimeout(function() { console.log(e); }, 1000);
})(i);
}
外層匿名函式立即執行,把當下的 i 作為參數傳入,函式內的 e 因此擁有 i 的一份複本。稍後傳給 setTimeout 的匿名函式持有的是對 e 的參照,而 e 不會被迴圈改變。
這也是 let 相較 var 的關鍵優勢所在:用 let 宣告迴圈變數時,每次迭代都會產生一個新的綁定,上述問題自然消失,不需要再包一層 IIFE。