在 JavaScript 裡,函式能做這五件事:
◆ 被指派給一個變數
◆ 被指派為某個物件的屬性
◆ 作為引數傳進另一個函式
◆ 作為函式的回傳值
◆ 用字面值直接建立
這五條加起來,就是「第一等函式」的定義。理解這一點,是從寫得出 JavaScript 到寫得好 JavaScript 的分水嶺。
最冷門、幾乎沒人用的方式,是用 new 去操作 Function 建構子:
var funcName = new Function([argname1, [... argnameN,]] body);
參數列可以有任意多個,最後一段是函式主體:
var add = new Function("x", "y", "return(x+y)");
print(add(2, 4)); // 印出 6
但函式主體一複雜,光是拼字串就夠折磨人了。所以語言提供了一層語法糖——字面值:
function add(x, y){
return x + y;
}
或者:
var add = function(x, y){
return x + y;
}
這層糖甜歸甜,卻也讓不少來自傳統語言的工程師誤解。事實上 function 這個關鍵字背後就是在 new 一個 Function 物件,並把參數列與函式主體原封不動送進建構子裡。
在全域作用域中宣告一個函式,說穿了只是替某個屬性賦值而已。上面那個 add,實際上是替全域物件添了一個名為 add 的屬性,值是一個函式物件。想通這件事很重要,因為它在語法上和下面這行並無本質差異:
var str = "This is a string";
兩者都只是動態地替全域物件多掛一個屬性。如此而已。
再來看個例子,證明函式和其他物件一樣,是獨立存在於 JavaScript 執行環境中的個體:
function p(){
print("invoke p by ()");
}
p.id = "func";
p.type = "function";
print(p);
print(p.id + ":" + p.type);
print(p());
輸出:
function (){
print("invoke p by ()");
}
func:function
invoke p by ()
p 引用的是一個函式物件,同時又能擁有屬性,跟其他物件一模一樣。
JavaScript 在處理函式參數上很有個性。你可以傳任意多個引數給一個函式,即使它宣告時根本沒定義形式參數。
function adPrint(str, len, option){
var s = str || "default";
var l = len || s.length;
var o = option || "i";
s = s.substring(0, l);
switch(o){
case "u":
s = s.toUpperCase();
break;
case "l":
s = s.toLowerCase();
break;
default:
break;
}
print(s);
}
adPrint("Hello, world");
adPrint("Hello, world", 5);
adPrint("Hello, world", 5, "l");
adPrint("Hello, world", 5, "u");
輸出依次是:
Hello, world
Hello
hello
HELLO
宣告時收了三個參數,呼叫時傳一個、兩個、三個都行,傳超過三個也不會出錯。
原因在於,JavaScript 引擎在呼叫函式時,傳進去的是一個類似陣列的內部值,叫做 arguments,它在函式物件被建立時就已初始化。只傳一個參數時,另外兩個形式參數的值就是 undefined。於是我們可以在函式內部自行處理這些 undefined,對外看起來就成了「我能處理任意參數」。
再看一個更能說明問題的例子:
function sum(){
var result = 0;
for(var i = 0, len = arguments.length; i < len; i++){
var current = arguments[i];
if(isNaN(current)){
throw new Error("not a number exception");
}else{
result += current;
}
}
return result;
}
print(sum(10, 20, 30, 40, 50));
print(sum(4, 8, 15, 16, 23, 42));
print(sum("new"));
輸出:
150
108
Error: not a number exception
sum 沒有任何顯式形參,卻能動態收下任意多個數字——靠的就是 arguments 這個偽陣列。
作用域是幾乎所有主流語言都有的概念,但 JavaScript 的做法有它的特殊之處:變數的作用域以函式為界,沒有區塊作用域。
在 Java 裡,我們可以這樣寫 for 迴圈的下標變數:
public void method(){
for(int i = 0; i < obj1.length; i++){
// do something
}
// 此時 i 已不存在
for(int i = 0; i < obj2.length; i++){
// do something else
}
}
同樣的邏輯搬到 JavaScript:
function func(){
for(var i = 0; i < array.length; i++){
// do something
}
// 此時 i 依然有值,等於 array.length
print(i);
}
迴圈結束後,i 還活得好好的。
JavaScript 的函式在局部作用域中執行,函式體內可以存取外層(可能是全域)的變數與函式。而它的作用域屬於詞法作用域——也就是說,作用域在定義時(詞法分析階段)就確定下來,而不是等到執行時才決定。
看這個例子:
var str = "global";
function scopeTest(){
print(str);
var str = "local";
print(str);
}
scopeTest();
初學者常猜是 global / local,但正確答案是:
undefined
local
原因在於,詞法分析結束、開始建構作用域鏈時,函式內用 var 宣告的變數會被放進這條鏈中,因此 str 在整個 scopeTest 裡從頭到尾都是「可見」的——只是第一行程式執行到時,這個 str 尚未被賦值,於是印出 undefined;接著第二行完成賦值,第三行自然印出 local。
至於函式為什麼不去存取外層那個 str?因為內層的 str 已經在整段函式中「遮」住了它。
在 Java 或 C/C++ 裡,方法必須依附於物件而存在,無法獨立。JavaScript 不同:函式本身就是一種物件,不屬於任何物件的一部分。在函式式編程的語境下,函式被視為「一等公民」,這正是理解函式式 JavaScript 的關鍵。
函式的上下文可以改變,因此函式內的 this 也可以改變。同一個函式可以作為 A 物件的方法,同時作為 B 物件的方法——因為函式本身是獨立的。要換上下文,用 Function 上的 call 或 apply。
兩者都用來替換函式中的 this,第一個參數就是新的 this 指向。實際感受一下:
// 定義一個人,名叫 jack
var jack = {
name : "jack",
age : 26
}
// 另一個人,名叫 abruzzi
var abruzzi = {
name : "abruzzi",
age : 26
}
// 一個全域函式
function printName(){
return this.name;
}
// 把上下文設為 jack
print(printName.call(jack));
// 把上下文設為 abruzzi
print(printName.call(abruzzi));
print(printName.apply(jack));
print(printName.apply(abruzzi));
只有一個參數時,call 和 apply 完全等價。參數不只一個時,差別就出現了:
setName.apply(jack, ["Jack Sept."]);
print(printName.apply(jack));
setName.call(abruzzi, "John Abruzzi");
print(printName.call(abruzzi));
輸出:
Jack Sept.
John Abruzzi
apply 的第二個參數是一個由所需參數組成的陣列;call 則是把參數一個個列在後面,用逗號隔開。
// 宣告一個函式,收兩個參數並回傳總和
function add(x, y){
return x + y;
}
var a = 0;
a = add;// 把函式指派給變數
var b = a(2, 3);// 呼叫新的函式 a
print(b);
印出 5。賦值之後,a 引用的是 add 這個函式物件(一段可執行的程式碼),所以 a(2, 3) 這樣的寫法完全成立。
var obj = {
id : "obj1"
}
obj.func = add;// 掛成 obj 的屬性
obj.func(2, 3);// 回傳 5
本質上和上一個例子相同。上一例的 a,其實就是全域物件(在瀏覽器環境中即 window)的一個屬性;只是我們很少直接提及全域物件,才分開來講。
// 進階列印函式的第二版
function adPrint2(str, handler){
print(handler(str));
}
// 轉大寫
function up(str){
return str.toUpperCase();
}
// 轉小寫
function low(str){
return str.toLowerCase();
}
adPrint2("Hello, world", up);
adPrint2("Hello, world", low);
輸出:
HELLO, WORLD
hello, world
注意 adPrint2 的第二個參數本身就是一個函式。把「處理方式」當成引數傳進去,函式內部照樣能呼叫它。這個特性在很多地方都派得上用場:當你要處理某些資料,卻還不確定該用什麼形式處理時,乾脆把「處理方式」抽象成一個函式包起來傳入。
最簡單的例子:
function currying(){
return function(){
print("curring");
}
}
currying 回傳一個匿名函式,這個匿名函式被執行時會印出 curring。單純呼叫 currying() 得到的,是那個函式本身:
function (){
print("curring");
}
要真正執行它,得寫成 currying()()。第一組括號呼叫 currying 本身,回傳值是函式;第二組括號再呼叫這個回傳值,這才會印出:
currying
把函式當資料傳來傳去,是 JavaScript 表達力真正的來源。一旦習慣了這個思路,很多原本要寫一大片的設計,都會變成幾行的組合。