先用最直白的話說:函數就是一段有名字、可以重複使用的程式碼區塊。最簡單的例子如下:
function sum(a, b) {
return a + b;
}
幾個容易踩坑的細節值得留意:
1. JavaScript 是區分大小寫的語言,關鍵字 function 不能寫成 Function 或 FUNCTION。
2. sum 是函數名稱,它並非必要(後面會談到匿名函數)。
3. return 用來回傳結果;若不寫,函數會預設回傳 undefined。想回傳多個值時,可以回傳陣列或物件。
最基礎的呼叫方式就是帶上函數名稱與括號:
var result = sum(1, 2);
參數行為是本篇的重點,以下用幾個實例說明。
var result = sum(1);
此時 result 為 NaN,因為參數 b 的值是 undefined。它不會報錯,反而容易在不知不覺中埋下 bug。
sum(1, 2, 3, 4, 5);
結果為 3,多餘的參數會被忽略。
function args() {
return arguments;
}
每個函數內部都有一個預設的類陣列物件 arguments,它保存了所有實際傳入的參數。呼叫 args(1,2,3,4,5,6) 時,arguments 的值就是 [1,2,3,4,5,6]。利用這一點,我們可以把上面的 sum 改寫得更靈活:
function sum() {
var res = 0;
for (i = 0; i < arguments.length; i++) {
res += arguments[i];
}
return res;
}
sum(1, 2, 3, 4); // 10
這是一個很重要的觀念:函數本身就是資料。看看下面兩種寫法:
function f() { return 1; }
var f = function() { return 1; };
這兩種定義完全等價。執行 typeof f 會得到 "function",可見在 JavaScript 中函數是一種資料型別。它有兩個重要特性:包含程式碼,並且能被執行。
再看一個例子:
var sum = function(a, b) { return a + b; };
var add = sum;
sum = undefined;
typeof add; // "function"
add(1, 2); // 3
把函數 sum 當成一個值賦給 add 之後,即使 sum 被設為 undefined,add 依然可以正常呼叫。這說明函數只是一次普通的賦值。
在 JavaScript 中,像 "abcd"、1、[1,2,3] 這樣不寫賦值目標的資料不會報錯,它們被稱為匿名資料。函數作為資料同樣可以是匿名的:
function(a) { return a; }
匿名函數有兩個主要用途:一是作為參數傳入另一個函數;二是立即執行它。
既然函數可以像其他資料一樣被賦值、複製,自然也就能作為參數傳入另一個函數。
function invoke_and_add(a, b) {
return a() + b();
}
function one() { return 1; }
function two() { return 2; }
invoke_and_add(one, two); // 3
invoke_and_add(function() { return 1; }, function() { return 2; });
直接把匿名函數當參數傳入,不需要額外命名。
回呼函數的定義是:把函數 A 傳入函數 B,並由函數 B 來執行函數 A,我們就稱函數 A 為回呼函數。若沒有名稱,則稱為匿名回呼函數。
回呼函數的主要好處有三點:不必為傳遞的函數額外命名,可減少全域變數;能節省大量程式碼;並有助於提升程式效能。
自呼叫函數是匿名函數的一種形式,定義之後立即執行:
(
function() {
alert('haha');
}
)()
語法看起來有點特別,但概念很簡單。它不必額外定義全域變數,而且只會執行一次,非常適合拿來做初始化工作。許多知名的 JavaScript 函式庫(例如 jQuery)的原始碼中大量運用了這個技巧。
既然函數是資料,而資料可以定義在函數裡,那麼把函數放進函數中也完全可行:
function a(param) {
function b(theinput) {
return theinput * 2;
}
return 'The result is ' + b(param);
}
也可以寫成:
var a = function(param) {
var b = function(theinput) {
return theinput * 2;
};
return 'The result is ' + b(param);
};
函數 b 定義在 a 內部,因此 a 的外部無法存取 b,這種函數也被稱為私有函數(private function)。執行 b(2) 會發現它並未定義,正好印證了它的私有性。
使用內部函數有兩個好處:減少全域變數,避免命名衝突帶來的 bug;具備私有性,可以設計出更完善的介面供外部呼叫。
function a() {
alert('a');
return function() {
alert('b');
};
}
呼叫 a() 會執行 alert('a'),並回傳另一個函數。使用方式如下:
var newFunc = a(); newFunc(); // 依序 alert a、alert b
也可以簡寫為 a()();。
既然函數能回傳函數,也就意味著可以用新函數替換舊函數:
a = a();
第一次執行 a 時 alert a,之後執行 a 則 alert b。這個技巧對初始化非常有用,因為 a 重寫了自己,避免日後重複執行初始化邏輯。
更簡潔的做法是在函數內部直接重寫自己:
function a() {
alert("a");
a = function() {
alert("b");
};
}
只有第一次呼叫才會 alert a,之後都會 alert b。
綜合前面幾節,來看一個整合的例子:
var c = function() {
function a() { alert('a'); }
function b() { alert('b'); }
a();
return b;
}(); // alert('a');
c(); // alert('b');
這個例子要注意三點:a、b 是內部函數;return b 回傳的是函數的參考;自呼叫的結果重寫了函數 c。理解這個例子,就能同時掌握內部函數、自呼叫函數與回傳函數的函數。
閉包是較難的部分,學習前先了解 JavaScript 的作用域(Scope)。
var a = 1;
function f() {
var b = 1;
return a;
}
f(); // a = 1
b; // b 未定義
a 是全域變數,b 定義在函數 f 內部。因此在 f 中 a、b 都可存取;在 f 之外則只能存取 a。
再看:
var a = 1;
function f() {
var b = 1;
function n() {
var c = 3;
}
}
函數 n 定義在 f 內部,它不僅能存取自己作用域的 c,還能存取父作用域的 b 與 a,這就是作用域鏈。
JavaScript 採用詞法作用域,也就是函數在「定義」時就確定了作用域,而非在「呼叫」時。
function f1() { var a = 1; f2(); }
function f2() { return a; }
f1(); // a 未定義
雖然 f1 呼叫了 f2,你可能期望 f2 能存取 f1 的區域變數 a,但事實並非如此。因為 f2 早已定義完成,其作用域中找不到 a。無論 f1 還是 f2,都只能存取自身的區域變數或全域變數。
實例 1:
function f() {
var b = "b";
return function() {
return b;
};
}
變數 b 存在於 f 的作用域中,全域無法直接存取。但 f 回傳的新函數可以存取 b:
var n = f(); n(); // 存取 b
實例 2:函數 f 不回傳函數,而是建立一個全域變數 n:
var n;
function f() {
var b = "b";
n = function() {
return b;
};
}
如此便能直接以 n() 存取 f 內的變數 b。
由此可以說:當一個函數指向它的父作用域(尤其是父作用域中的區域變數)時,就形成了閉包。閉包其實提供了一個介面,讓外部得以存取內部變數。
當我們建立一個帶參數的函數 f,參數就成了 f 的區域變數,我們可以建立一個內部函數來回傳它:
function f(arg) {
var n = function() {
return arg;
};
arg++;
return n;
}
var m = f(123);
m(); // 124
迴圈中很容易出現表面正常、實際有誤的 bug:
function f() {
var a = [];
var i;
for (i = 0; i < 3; i++) {
a[i] = function() {
alert(i);
return i;
};
}
return a;
}
var a = f();
a[0](); // 3
a[1](); // 3
a[2](); // 3
我們期望得到 0、1、2,結果卻都是 3。原因是這三個閉包都指向同一個變數 i,閉包記住的是 i 的「參考」而非當時的值。迴圈結束後 i 為 3,所以結果都是 3。
正確的寫法:
function f() {
var a = [];
var i;
for (i = 0; i < 3; i++) {
a[i] = (function(x) {
return function() {
alert(x);
return x;
};
})(i);
}
return a;
}
var a = f();
a[0](); // 0
a[1](); // 1
a[2](); // 2
這裡再用一個閉包把 i 變成區域變數 x,每次的 x 都是不同的值。若不易理解自呼叫函數,也可以寫成:
function f() {
function makeClosure(x) {
return function() {
return x;
};
}
var a = [];
var i;
for (i = 0; i < 3; i++) {
a[i] = makeClosure(i); // 用來記住 i 的值
}
return a;
}