函式是模組化設計的基礎。想寫出結構清楚、好維護的 AJAX 應用,就必須先弄清 JavaScript 的函式究竟和別的語言差在哪裡。最關鍵的一點是:在 JavaScript 中,每個函式都是一個物件。
先看四種合法寫法:
function func1(...) { ... } // 具名函式宣告
var func2 = function(...) { ... }; // 函式表達式,指向匿名函式
var func3 = function func4(...) { ... }; // 表達式,但函式本身有名
var func5 = new Function(); // 透過建構子產生
這在其他語言裡幾乎不可能出現。原因就在於函式是物件,可以被賦值、被當成參數傳遞、也可以被動態組裝。
JavaScript 的內部物件——Date、Array、String、Function 等——其建構方式由語言本身定義,而非由使用者指定。函式對應的型別就是 Function,因此下列兩段程式完全等價:
function myFunction(a, b) {
return a + b;
}
// 等價於
var myFunction = new Function("a", "b", "return a + b");
這就和 var myArray = [] 等同於 var myArray = new Array() 是同一個道理。當解譯器遇到函式宣告語法時,內部會自動構造一個 Function 物件來保存它。
用 new Function() 的語法如下,所有參數都是字串,前 n 個是參數名、最後一個是函式主體:
var funcName = new Function(p1, p2, ..., pn, body);
實務上很少這樣寫,因為函式主體通常有很多行,塞成字串之後可讀性極差、也不利於除錯。它真正存在的理由是:要為函式物件掛屬性與方法,必須有 Function 這個型別作為依附點。
在函式宣告後面直接加上括號,就會在建立完成後立刻執行:
var i = function(a, b) {
return a + b;
}(1, 2);
alert(i); // 顯示 3
注意 i 拿到的是回傳值 3,而不是函式本身,因為括號的優先權高於等號。這在需要避免命名污染、或想把長篇程式碼做區塊化封裝時很好用。
另外,這兩種寫法雖然等價,行為上卻有一個關鍵差異:
function funcName() { /* 函式主體 */ }
// 等價於
var funcName = function() { /* 函式主體 */ };
前者建立的是具名函式,可以在呼叫之後才宣告;後者建立的是匿名函式,只是讓變數指向它,因此必須先定義才能呼叫:
func();
var func = function() { alert(1); } // 錯誤:func 未定義
func();
function func() { alert(1); } // 正確
func();
var someFunc = function func() { alert(1); }; // 也能正確執行
也就是說,JavaScript 雖然是直譯式語言,但在呼叫時會去檢查整個程式碼中是否存在對應的宣告——而這種「提前可用」的效果,只有用 function funcName() 形式定義的才享有。
alert(typeof(Function)); // function alert(typeof(new Function())); // function alert(typeof(Array)); // function alert(typeof(Object)); // function alert(typeof(new Array())); // object alert(typeof(new Date())); // object
可見函式本身就是一個建構子(constructor)。所有 typeof 回傳 "function" 的物件都屬於函式物件;反過來說,所有建構子都是物件,但不是所有物件都是建構子。
Function.prototype.method1 = function() {
alert("function");
};
function func1(a, b, c) { return a + b + c; }
func1.method1(); // 顯示 function
func1.method1.method1(); // 也可以這樣呼叫
最後一行看起來饒舌,但邏輯很清楚:method1 本身也是函式,因此同樣擁有函式物件的屬性與方法——這是一種遞歸的性質。
再往上一層,Object 是所有物件(包含函式物件)的基礎,改寫 Object.prototype 就能讓全部物件共用同一套方法:
Object.prototype.getType = function() {
return typeof(this);
};
var array1 = new Array();
function func1(a, b) { return a + b; }
alert(array1.getType()); // object
alert(func1.getType()); // function
function func1(theFunc) { theFunc(); }
function func2() { alert("ok"); }
func1(func2);
這是整個事件機制的地基。例如要在頁面載入後做初始化,寫 window.onload = init; 就是把 init 這個函式物件放進 onload 的呼叫清單裡——注意是 init 而非 init(),加上括號就變成立即執行、把回傳值放進去了。
每次呼叫函式時,除了宣告的參數之外,還會產生一個名為 arguments 的物件。它像陣列但不是陣列,有 length、可用 arguments[i] 取值,內容是「實際傳入的參數」:
function func(a, b) {
alert(a);
alert(b);
for (var i = 0; i < arguments.length; i++) {
alert(arguments[i]);
}
}
func(1, 2, 3); // 依序顯示 1, 2, 1, 2, 3
這意味著即使函式宣告時不寫參數清單,一樣能透過 arguments 取得所有傳入值,彈性極大。
arguments 還有一個 callee 屬性,指向函式本身,適合用在匿名函式的遞迴:
var sum = function(n) {
if (1 == n) return 1;
else return n + arguments.callee(n - 1);
};
alert(sum(100));
若不透過 callee 而直接呼叫 sum,實際上是去參照一個外部變數,語意上並沒有表達「呼叫自己」。另外,arguments 不是 Array 的實例——為 Array.prototype 掛上的屬性,在 arguments 上讀會得到 undefined。
Function.prototype.apply(thisArg, argArray); Function.prototype.call(thisArg[, arg1[, arg2, ...]]);
兩者作用相同:把函式綁定到另一個物件上執行。差別只在參數傳遞的形式——apply 收陣列,call 收散列參數。第一個參數 thisArg 會成為函式內部 this 的值。
function func1() {
this.p = "func1-";
this.A = function(arg) { alert(this.p + arg); };
}
function func2() {
this.p = "func2-";
this.B = function(arg) { alert(this.p + arg); };
}
var obj1 = new func1();
var obj2 = new func2();
obj1.A("byA"); // func1-byA
obj2.B("byB"); // func2-byB
obj1.A.apply(obj2, ["byA"]); // func2-byA
obj2.B.apply(obj1, ["byB"]); // func1-byB
obj1.A.call(obj2, "byA"); // func2-byA
obj2.B.call(obj1, "byB"); // func1-byB
obj1 的方法 A 被綁到 obj2 上執行後,整個執行環境就跟著搬了過去。這也是 JavaScript 實現「借用方法」與控制 this 指向的主要手段。
最後別把兩個 length 搞混:arguments.length 是實際傳入的參數個數,而函式物件自身的 length 屬性是宣告時定義的參數個數。
function sum(a, b) { return a + b; }
alert(sum.length); // 2
var obj1 = new Object();
var obj2 = new Object();
obj1.p = 1;
obj2.p = 2;
obj1.getP = function() { alert(this.p); };
obj1.getP(); // 1
obj2.getP = obj1.getP;
obj2.getP(); // 2
getP 只定義了一次,掛到不同物件上執行就顯示不同結果。this 並非固定指向定義它的物件,而是指向「當下呼叫它的那個物件」。apply 與 call 本質上就是強制改寫 this 的值。
理解這一點,也就能理解 JavaScript 物件的本質:一個物件就是若干屬性與方法的集合,而同一個方法可以動態地屬於多個集合。由於這種動態性,物件的方法要引用自己的其他成員時,this 不能省略——寫成 alert(p) 會去找外層環境的 p,而不是 obj1 的屬性。
最後一個實務技巧:利用 new 操作函式物件來製造類別的效果,物件名稱同時扮演命名空間的角色:
var namespace1 = new Object();
namespace1.class1 = function() {
// 初始化物件的程式碼
};
var obj1 = new namespace1.class1();