函數是 JavaScript 世界裡最核心的 building block。只要理解了函數,你就掌握了這個語言大半的靈魂。本文整理自一篇廣為流傳的經典入門教程,從「如何定義函數」一路談到「函數作為物件」與「原型(prototype)」機制,適合想打好基礎的開發者細細研讀。
在 JavaScript 中定義函數並不止一種寫法。以下幾種都是合法的,但它們在底層的實作方式其實存在差異。
大多數人使用的標準寫法如下:
functionName([parameters]) { functionBody };
例如:
function add(a, b)
{
return a + b;
}
alert(add(1, 2)); // 結果 3
當你用這種方式定義時,函數內容會先被編譯(但不會立即執行,除非你主動呼叫它)。此外還有一個容易被忽略的細節:建立函數的同時,一個同名的物件也被悄悄建立了。就上面的例子而言,此刻你手上其實有一個名為 add 的物件。
你也可以把一個匿名函數指派給某個變數來完成定義:
var add = function(a, b)
{
return a + b;
}
alert(add(1, 2)); // 結果 3
這段程式碼和前一種寫法效果相同。語法看起來有點陌生,但它更能凸顯「函數本身就是一個物件」這個觀念——你不過是替這個物件取了一個名字,就像 var myVar = [1,2,3] 一樣。這種寫法同樣會被編譯。
指派時,函數並不一定是匿名的。你也可以替它命名,此後透過函數名或變數名都能呼叫它:
var add = function theAdd(a, b)
{
return a + b;
}
alert(add(1, 2)); // 結果 3
alert(theAdd(1, 2)); // 結果同樣是 3
這種寫法在物件導向程式設計中特別有用,因為我們可以輕易地把函數變成某個物件的屬性(方法):
var myObject = new Object();
myObject.add = function(a, b) { return a + b; };
// myObject 現在擁有一個名為 add 的方法
myObject.add(1, 2);
透過 new 運算子也能定義函數,但這是最少見、也最不推薦的方式,除非有特別的理由。語法如下:
varName = new Function([param1Name, param2Name, ... paramNName], functionBody);
例如:
var add = new Function("a", "b", "return a + b;");
alert(add(3, 4)); // 結果 7
請注意 Function 的 F 是大寫,這告訴 JavaScript 我們要建立一個型別為 Function 的物件;同時參數名稱與函數體都是以「字串」形式傳入的。JavaScript 知道最後一個字串就是函數體,因此你可以自由增加參數。若程式碼太長,可用反斜線 \ 或字串串接 + 換行撰寫。
這種方式最大的缺點是:函數不會被編譯,因此執行效率可能較差。原因在下面的例子裡一目了然:
function createMyFunction(myOperator)
{
return new Function("a", "b", "return a " + myOperator + " b;");
}
var add = createMyFunction("+"); // 建立加法函數
var subtract = createMyFunction("-"); // 建立減法函數
var multiply = createMyFunction("*"); // 建立乘法函數
alert("加的結果=" + add(10, 2)); // 12
alert("減的結果=" + subtract(10, 2)); // 8
alert("乘的結果=" + multiply(10, 2)); // 20
由於編譯器無法事先得知最終的程式碼長相,new Function(...) 的內容便無法被編譯。這種技巧的價值在於「讓使用者自行建立函數」的情境,例如遊戲中允許玩家賦予角色自訂「行為」。除此之外,一般情況應盡量避免。
函數是 JavaScript 裡一種特殊的物件,也是第一個「類別資料型別(class data type)」。這意味著我們能為它加上屬性。
前面提過,定義函數時 JavaScript 會在背後建立一個同名物件,其型別為 function。以下例子裡,我們其實已經建立了一個名為 Ball 的物件:
function Ball() // 這行宣告建立了一個名為 Ball 的物件
{
i = 1;
}
alert(typeof Ball); // 結果 "function"
既然函數是物件,我們就能為它加上屬性:
function Ball() { }
Ball.callsign = "The Ball"; // 為 Ball 增加屬性
alert(Ball.callsign); // 輸出 "The Ball"
因為函數是物件,我們可以把它的「指標」指派給變數。下例中,變數 ptr 指向了物件 myFunction:
function myFunction(message)
{
alert(message);
}
var ptr = myFunction; // ptr 指向 myFunction
ptr("hello"); // 相當於 myFunction("hello"),輸出 "hello"
函數指標在物件導向中非常實用,例如讓多個物件共用同一個函數:
function sayName(name) { alert(name); }
var object1 = new Object();
var object2 = new Object();
var object3 = new Object();
object1.sayMyName = sayName; // 將同一函數指派給三個物件
object2.sayMyName = sayName;
object3.sayMyName = sayName;
object1.sayMyName("object1"); // 輸出 "object1"
object2.sayMyName("object2"); // 輸出 "object2"
object3.sayMyName("object3"); // 輸出 "object3"
由於儲存的是指標而非函數本體,當函數物件自身改變時,所有指向它的指標都會跟著改變:
function myFunction() { alert(myFunction.message); }
myFunction.message = "old";
var ptr1 = myFunction;
var ptr2 = myFunction;
ptr1(); // 輸出 "old"
ptr2(); // 輸出 "old"
myFunction.message = "new";
ptr1(); // 輸出 "new"
ptr2(); // 輸出 "new"
我們也可以在函數建立後重新指派它,但必須針對函數物件本身,而非它的指標:
function myFunction() { alert("Old"); }
myFunction(); // 輸出 "Old"
myFunction = function() { alert("New"); };
myFunction(); // 輸出 "New"
舊函數被捨棄了。若想保留,可在變更前先存一個指標:
function myFunction() { alert("Old"); }
var savedFunction = myFunction;
myFunction = function() { alert("New"); };
myFunction(); // 輸出 "New"
savedFunction(); // 輸出 "Old"
但要小心:如果你改的是指標變數本身,只會建立另一個函數,並不會影響原本的函數。
函數裡面還可以再包一個函數。下例中 getHalfOf 內部有一個 calculate:
function getHalfOf(num1, num2, num3)
{
function calculate(number)
{
return number / 2;
}
var result = "";
result += calculate(num1) + " ";
result += calculate(num2) + " ";
result += calculate(num3);
return result;
}
var resultString = getHalfOf(10, 20, 30);
alert(resultString); // 輸出 "5 10 15"
巢狀函數只能在內部呼叫,你不能從外部用 getHalfOf.calculate(10) 存取它,因為 calculate 只在外部函數執行期間存在。
那麼命名衝突怎麼辦?若內外都有名為 calculate 的函數,編譯器會先搜尋局部作用域,因此會採用內嵌的版本;若刪去內嵌函數,才會退回使用全域的 calculate。
函數還有一個與眾不同的能力:它能作為一個資料型別的「藍圖」。這在物件導向中被廣泛用來模擬使用者自訂的資料型別。
定義一個函數的同時,其實也定義了一個新的資料型別,可以用來建立物件:
function Ball() { }
var ball0 = new Ball(); // ball0 指向一個新物件
alert(ball0); // 輸出 "Object"
new Ball() 做了什麼?new 關鍵字先建立一個型別為 Object 的新物件,接著執行 Ball(),再把這個參照交給 ball0。
然而,若每次建立物件後都要手動補上屬性,當有多個實例時就會很麻煩——很容易漏掉某個:
var ball0 = new Ball(); ball0.name = "ball-0"; var ball1 = new Ball(); ball1.name = "ball-1"; var ball2 = new Ball(); // 糟糕,我忘了幫 ball2 加上 name!
解法是使用 this 關鍵字。在函數中,this 指向呼叫該函數的物件。把它寫進建構函數裡,就能自動為每個實例設定屬性:
function Ball(message, specifiedName)
{
alert(message);
this.name = specifiedName;
}
var ball0 = new Ball("creating new Ball", "Soccer Ball");
alert(ball0.name); // 輸出 "Soccer Ball"
是 new 關鍵字讓建構函數真正被執行,此時 this 指向 ball0,所以 this.name = specifiedName 就等於 ball0.name = "Soccer Ball"。這種寫法更具擴充性,也能讓人一眼看懂這個型別有哪些屬性:
function Ball(color, specifiedName, owner, weight)
{
this.name = specifiedName;
this.color = color;
this.owner = owner;
this.weight = weight;
}
var ball0 = new Ball("black/white", "Soccer Ball", "John", 20);
var ball1 = new Ball("gray", "Bowling Ball", "John", 30);
var ball2 = new Ball("yellow", "Golf Ball", "John", 55);
屬性不限於字串或數字,也可以放物件。例如讓 supervisor 成為 Employee 的一個屬性:
function Employee(name, salary, mySupervisor)
{
this.name = name;
this.salary = salary;
this.supervisor = mySupervisor;
}
var boss = new Employee("John", 200);
var manager = new Employee("Joan", 50, boss);
既然函數也是物件,我們甚至能讓函數充當屬性(也就是方法):
function Employee(name, salary)
{
this.name = name;
this.salary = salary;
this.addSalary = addSalaryFunction;
this.getSalary = function()
{
return this.salary;
};
}
function addSalaryFunction(addition)
{
this.salary = this.salary + addition;
}
var boss = new Employee("John", 200000);
boss.addSalary(10000);
alert(boss.getSalary()); // 210000
這裡有個關鍵差異:像 getSalary 這種寫在建構函數內的函數,每建立一個實例就會複製一份程式碼,既耗記憶體又拖慢建構速度;而 addSalary 只是指向同一個函數。若把方法都提到外部定義,就能讓所有實例共用同一份程式碼,效率更好——而更進一步的優化,正是下一節要談的 prototype。
每個建構函數都自帶一個名為 prototype 的屬性,用來宣告某個類別共用的變數或函數。你不需要明確宣告它,因為它天生就存在:
function Test() { }
alert(Test.prototype); // 輸出 "Object"
由於 prototype 是一個物件,你能為它加上屬性,而這些屬性會成為所有實例的共用屬性:
function Fish(name, color)
{
this.name = name;
this.color = color;
}
Fish.prototype.livesIn = "water";
Fish.prototype.price = 20;
var fish1 = new Fish("mackarel", "gray");
var fish2 = new Fish("goldfish", "orange");
var fish3 = new Fish("salmon", "white");
即使我們從未替每條魚個別宣告 livesIn 與 price,牠們都擁有這些屬性。原因是物件建立時,建構函數會把自己的 prototype 指派給新物件的內部屬性 __proto__,物件便是靠它來查找屬性。
用 prototype 來掛共用函數有個明顯好處:不必在每次建立物件時重新建立並初始化函數。把前面的 Employee 例子改寫如下:
function Employee(name, salary)
{
this.name = name;
this.salary = salary;
}
Employee.prototype.getSalary = function getSalaryFunction()
{
return this.salary;
};
Employee.prototype.addSalary = function addSalaryFunction(addition)
{
this.salary = this.salary + addition;
};
var boss1 = new Employee("Joan", 200000);
var boss2 = new Employee("Kim", 100000);
var boss3 = new Employee("Sam", 150000);
alert(boss1.getSalary()); // 200000
alert(boss2.getSalary()); // 100000
alert(boss3.getSalary()); // 150000
此時每個實例(boss1、boss2、boss3)都透過內部的 __proto__ 指向建構函數的 prototype;呼叫方法時,物件會在 __proto__ 中找到並執行對應程式碼。與前面「每個實例各複製一份」的寫法相比,這裡完全沒有程式碼的複製,這正是 prototype 機制強大又高效的地方。