JavaScript 用 function 關鍵字定義函式,而「定義」本身有好幾種姿勢,各自的行為差異不小,值得一次弄清楚。
最直覺的形式:
function functionName(parameters) {
// 執行的程式碼
}
宣告之後不會立刻執行,等到被呼叫時才跑。
function myFunction(a, b) {
return a * b;
}
函式也可以用表達式的形式定義,並存進變數:
var x = function (a, b) { return a * b };
var z = x(4, 3);
這其實是一個匿名函式——它沒有名字,靠變數名來呼叫。
函式也能透過內建的 Function() 建構子產生:
var myFunction = new Function("a", "b", "return a * b");
var x = myFunction(4, 3);
但實際上你幾乎不需要這樣寫。上面那段完全等價於:
var myFunction = function (a, b) { return a * b };
var x = myFunction(4, 3);
用建構子的主要缺點是:函式本體是字串,會在執行時期才被編譯,效能較差,也失去了語法高亮與靜態分析的機會。
Hoisting 是 JavaScript 預先把當前作用域的宣告「提到前面」的行為,它同時作用於變數宣告與函式宣告。因此函式可以在宣告之前被呼叫:
myFunction(5);
function myFunction(y) {
return y * y;
}
但用表達式定義的函式無法提升——因為被提升的只有變數宣告,賦值還是留在原地。
函式表達式可以「自我呼叫」:只要在表達式後面緊跟一組括號,它就會立刻執行。注意這招只能用在表達式上,宣告式的函式不行。
(function () {
var x = "Hello!!"; // 我將呼叫我自己
})();
還有幾種等價的變體:
!function(){}();
+function(){}();
-function(){}();
~function(){}();
~(function(){})();
void function(){}();
(function(){}());
最常見、也最推薦的仍是第一種。
用 typeof 判斷函式會得到 "function",但更準確的描述是:函式就是物件。它有屬性也有方法。例如 arguments.length 回傳呼叫時實際收到的參數個數:
function myFunction(a, b) {
return arguments.length;
}
而 toString() 會把函式當成字串回傳:
function myFunction(a, b) { return a * b; }
var txt = myFunction.toString();
作為物件的屬性被定義時,我們稱它為「方法」;若是用來建立新物件,則稱之為「建構子」。
下面這段把三種定義方式與「函式作為資料使用」的觀念一起演一遍:
<script type="text/javascript">
/* 1. 一般寫法 */
function print(msg) { document.write(msg, "<br/>"); }
/* 2. 建構子寫法 */
var add1 = new Function('a','b','return a+b');
/* 3. 函式直接量(匿名) */
var result = function(x, y){ return x + y; };
/* 也可以指定名稱 */
var result2 = function fact(x){ return x < 1 ? 1 : x * fact(x - 1); };
print('add1(5,6) = ' + add1(5, 6));
print('result(3,4) = ' + result(3, 4));
print('result2(3) = ' + result2(3));
/* 函式作為資料傳遞 */
function add(x, y) { return x + y; }
function multiply(x, y) { return x * y; }
function operate(operator, operand1, operand2) {
return operator(operand1, operand2);
}
// 計算 (2+3) + (4*5)
var i = operate(add, operate(add, 2, 3), operate(multiply, 4, 5));
print('(2+3) + (4*5) = ' + i);
// 用物件表格管理運算子
var operators = {};
operators['add'] = function(x, y){ return x + y; };
operators['multiply'] = function(x, y){ return x * y; };
operators['pow'] = Math.pow;
function operate2(op_name, a, b) {
if (operators[op_name] == null) return "unknown operator";
return operators[op_name](a, b);
}
print(operate2("add", "hello", operate2("add", " ", "world")));
print(operate2("pow", 10, 2));
</script>
輸出會是 11、7、6、25,以及最後的 hello world 與 100。
最後一段值得多看一眼:把函式放進物件裡用字串索引取出來呼叫,其實就是「策略模式」與後來的「命令表」的雛形,也是理解 JavaScript 為何能寫得這麼靈活的關鍵——函式在這裡只是又一個可以四處傳遞的值而已。