JavaScript 的函式不只是「一段可重複呼叫的程式碼」,它同時也是一種特殊的物件。理解這一點,之後的原型、建構子、閉包等概念才會連得起來。以下由淺入深整理。
function add(a, b) {
return a + b;
}
alert(add(1, 2)); // 3
宣告函式時,內容會被編譯但不會立即執行,直到我們呼叫它。而且關鍵的一點是:建立函式的同時,一個同名的物件也被建立了。
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(1, 2);
函式是第一類(first-class)資料型別,代表它可以被賦值、傳參、附加屬性。
物件的建立
function ball() { // 這個宣告實際上建立了一個名為 ball 的物件
i = 1;
}
alert(typeof ball); // "function"
甚至可以把內容印出來,會看到函式本身的程式碼:
alert(ball);
// function ball()
// {
// i = 1;
// }
屬性的附加
function Ball() { }
ball.callsign = "The ball";
alert(ball.callsign); // "The ball"
function myFunction(message) {
alert(message);
}
var ptr = myFunction; // ptr 指向 myFunction
ptr("hello"); // 等同 myFunction("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
function get(a, b, c) {
function cal(n) {
return n / 2;
}
var result = "";
result += cal(a) + " ";
result += cal(b) + " ";
result += cal(c);
return result;
}
var resultString = get(10, 20, 30);
alert(resultString); // "5 10 15"
巢狀函式只能在內部呼叫。也就是說 getHalfOf.calculate(10) 這種寫法行不通,因為 calculate 只在外部函式執行期間存在。
function calculate(number) {
return number / 3;
}
function getHalfOf(num1, num2, num3) {
function calculate(number) {
return number / 2;
}
var result = "";
result += calculate(num1) + " ";
result += calculate(num2) + " ";
result += calculate(num3);
return result;
}
alert(getHalfOf(10, 20, 30)); // "5 10 15"
編譯器會優先搜尋局部作用域,因此這裡用的是內層的 calculate。若把內層版本刪掉,就會改用全域版本。這正是作用域鏈的運作方式。
函式另一個特殊能力是可以當成自訂資料型別的藍圖,這是模擬物件導向的基礎。
function Ball() { }
var ball0 = new Ball();
alert(ball0); // "object"
new Ball() 做了兩件事:建立一個新物件,然後執行 Ball() 並把該物件作為 this 傳入。
function Ball(message) {
alert(message);
}
var ball0 = new Ball("creating new Ball"); // 建立物件並輸出訊息
ball0.name = "ball-0";
alert(ball0.name); // ball-0
上面第 4 行其實可以展開成:
var ball0 = new Object();
ball0.construct = Ball;
ball0.construct("creating new ball");
ball0.name = "ball-0";
alert(ball0.name);
用 this 自動附加屬性
若每個實例都要手動加屬性,很容易漏掉:
function Ball() { }
var ball0 = new Ball();
ball0.name = "ball-0";
var ball1 = new Ball();
ball1.name = "ball-1";
var ball2 = new Ball();
alert(ball0.name); // ball-0
alert(ball1.name); // ball-1
alert(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);
var balloon = new Ball("red", "Balloon", "Pete", 10);
alert(ball0.name); // Soccer Ball
alert(balloon.name); // Balloon
alert(ball2.weight); // 55
屬性值也可以是物件:
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);
var teamLeader = new Employee("Rose", 50, boss);
alert(manager.supervisor.name + " is the supervisor of " + manager.name);
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
差別可以透過實驗驗證:
var boss1 = new Employee("John", 200000);
var boss2 = new Employee("Joan", 200000);
// getSalary 各自獨立
boss1.getSalary.owner = "boss1";
boss2.getSalary.owner = "boss2";
alert(boss1.getSalary.owner); // boss1
alert(boss2.getSalary.owner); // boss2
// addSalary 共用同一個函式物件
boss1.addSalary.owner = "boss1";
boss2.addSalary.owner = "boss2";
alert(boss1.addSalary.owner); // boss2
alert(boss2.addSalary.owner); // boss2
把函式寫在建構子內部的代價有兩個:一是每個實例都要保存一份程式碼拷貝,二是建立物件的時間變長。因此更好的寫法是把共用函式提到外部:
function Employee(name, salary) {
this.name = name;
this.salary = salary;
this.addSalary = addSalaryFunction;
this.getSalary = getSalaryFunction;
}
function getSalaryFunction() {
return this.salary;
}
function addSalaryFunction(addition) {
this.salary = this.salary + addition;
}
每個建構函式都有一個 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");
alert(fish1.name + "," + fish1.color + "," + fish1.livesIn + "," + fish1.price);
// mackarel, gray, water, 20
我們從未替每條魚個別宣告 livesIn 與 price,卻都能讀到。原因是物件被建立時,建構函式會把自己的 prototype 指派給新物件的內部屬性 [[Prototype]](舊寫法為 __proto__),而屬性查找會沿著這條原型鏈往上找。
用同樣的方式掛上共用方法,就不必在每次建立物件時重新產生一份函式:
function Employee(name, salary) {
this.name = name;
this.salary = salary;
}
Employee.prototype.getSalary = function () {
return this.salary;
};
Employee.prototype.addSalary = function (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
三個實例各自有一個內部屬性指向 Employee 的 prototype,呼叫 getSalary 時,引擎在原型上找到並執行該程式碼。
補充兩點現代寫法:ES6 的 class 語法本質上就是原型繼承的語法糖,class 內部定義的方法自動掛在 prototype 上;而若要處理繼承關係,Object.create 與 ES6 的 extends 都比手動操作 __proto__ 來得可靠。