JavaScript 的函數是一等公民,這句話背後其實包含了很多具體含義:函數可以像值一樣被賦值、傳參、附加屬性,也可以作為建構器、被閉包包住、拿來做模組封裝。本文把這些基礎但關鍵的用法系統性地整理一遍,每一節都附上可直接執行的程式碼。
函數宣告(function declaration)會被提升,因此在宣告之前就能呼叫。
function add() {
alert("函數建立成功");
}
add();
函數運算式(function expression)不會提升,必須先賦值給變數才能使用。
var testFunction = function () {
alert("這是一個匿名函數");
};
testFunction();
建構器方式,以字串形式組出函數本文,較少使用且不利於優化:
var fn = new Function('x', 'return x * 2');
函數可以掛屬性,這點常被忽略卻很實用:
function ball() {}
ball.name1 = "testing"; // 為函數物件加上屬性
alert(ball.name1); // 讀取
alert(typeof ball); // "function"
函數可以被賦值給變數、放進物件成為方法,多個物件也可以共用同一個函數參照:
function sayName(name1) { alert(name1); }
var obj1 = new Object();
var obj2 = new Object();
obj1.sayMyName = sayName; // 把參照交給物件,形成方法
obj2.sayMyName = sayName;
obj1.sayMyName("張三");
obj2.sayMyName("李四");
因為共用同一個參照,函數物件上的屬性變化會被所有持有者看到:
function add() {}
add.message = "chaiyesong";
var ptr1 = add;
var ptr2 = add;
add.message = "123";
alert(ptr1.message); // "123",ptr1 與 add 指向同一個函數物件
alert(ptr2.message); // "123"
但若把變數重新指向另一個函數,只是改變了該變數的參照,原本共用同一物件的關係就被切斷了:
var ptr = add;
ptr = function () { alert("ptr"); }; // ptr 指向新函數
add = function () { alert("two"); }; // add 也指向另一個新函數
add(); // "two"
ptr(); // "ptr"
任何函數都可以用 new 呼叫,此時函數內部的 this 會指向新建立的物件。
function Ball(message) { alert(message); }
var ball0 = new Ball("testing");
ball0.name1 = "ball-0";
alert(ball0.name1);
也可以把函數參照掛到物件的屬性上,透過該屬性呼叫:
var ball0 = new Object();
ball0.construct = Ball; // 把函數參照指向物件的建構器
ball0.construct("ceshi"); // 透過這個屬性執行函數
ball0.name1 = "testing";
alert(ball0.name1);
掛在 prototype 上的屬性與方法由所有實例共享,這是節省記憶體的關鍵。而寫在建構器內部的屬性則是每個實例各自獨立。
function Fish(name1, color1) {
this.name1 = name1; // 每隻魚各自擁有
this.color1 = color1;
}
Fish.prototype.LivesIn = "water"; // 所有魚共享
Fish.prototype.price = 20;
var fish1 = new Fish("mackrel", "gray");
var fish2 = new Fish("goldfish", "orange");
var fish3 = new Fish("salmon", "white");
for (var i = 1; i <= 3; i++) {
var fish = eval("fish" + i); // 取得指向該實例的參照
alert(fish.name1 + "," + fish.color1 + "," + fish.LivesIn + "," + fish.price);
}
把方法掛在 prototype 上的效益更明顯——若寫在建構器裡,每次 new 都會重新建立一份函數,實例一多就很浪費:
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);
alert(boss1.getSalary()); // 200000
把匿名函數包在小括號裡再立刻呼叫,可以建立一個一次性的作用域:
(function (x, y) {
alert(x + y); // 5
})(2, 3);
也可以把執行結果回傳給變數:
var f2 = function () {
return "ok";
}();
alert(f2); // "ok"
閉包指的是函數連同它能存活的外部作用域一起被保留。最典型的應用是讓變數在函數執行完畢後仍然留在記憶體中:
function box() {
var age = 100;
return function () { // 真正被呼叫的是這個內部函數
age++;
return age;
};
}
var b = box();
alert(b()); // 101
alert(b()); // 102
alert(b()); // 103
box() 早已執行完畢,但它的內部函數仍持有 age 的參照,因此 age 不會被回收,狀態得以在多次呼叫之間延續。
閉包另一個常見用途是封裝私有成員:
function Box() {
var age = 100; // 私有變數
function run() { // 私有函數
return '運行中...';
}
this.get = function () { // 對外公開的特權方法
return age + run();
};
}
var box = new Box();
alert(box.get()); // "100運行中..."
// alert(box.age); // undefined,外部無法存取
也可以搭配 getter / setter 做受控存取:
function Person(value) {
var user = value;
this.getUser = function () { return user; };
this.setUser = function (value) { user = value; };
}
這是最容易出錯的一段。下面的程式碼不會輸出 0 到 4,而是全部輸出 5:
function box() {
var arr = [];
for (var i = 0; i < 5; i++) {
arr[i] = function () { return i; }; // 捕獲的是同一個 i
}
return arr;
}
var b = box();
for (var i = 0; i < b.length; i++) {
document.writeln(b[i]()); // 全部印出 5
}
原因是所有閉包共用同一個 i 變數,迴圈結束後 i 的值是 5。
解法一:用 IIFE 建立獨立作用域並回傳結果。
function box1() {
var arr1 = [];
for (var i = 0; i < 5; i++) {
arr1[i] = (function (num) {
return num; // 把當下的 i 當作值傳入
})(i);
}
return arr1;
}
解法二:IIFE 回傳函數本身,讓每個閉包各自記住自己的 num。
function box3() {
var arr3 = [];
for (var i = 0; i < 5; i++) {
arr3[i] = (function (num) {
return function () { return num; };
})(i);
}
return arr3;
}
var b3 = box3();
for (var i = 0; i < b3.length; i++) {
document.writeln(b3[i]()); // 0 1 2 3 4
}
而在支援 ES6 的環境中,只要把 var 換成 let 就解決了——let 在每次迴圈迭代都建立新的 bindings:
for (let i = 0; i < 5; i++) {
arr[i] = function () { return i; }; // 正確輸出 0 1 2 3 4
}
把一段一次性邏輯包進 IIFE,執行完畢後區域變數就能被回收:
function box(count) {
(function () {
for (var i = 0; i < count; i++) { /* ... */ }
})();
// 這裡無法存取 i,作用域已經結束
}
寫法一:物件字面量回傳公開介面。
var box = function () {
var user = 'TT'; // 私有變數
function run() { // 私有函數
return '運行中...';
}
return {
publicGo: function () { // 對外公開的介面
return user + run();
}
};
}();
alert(box.publicGo()); // "TT運行中..."
寫法二:實例化自訂物件後掛上方法。
function Desk() {}
var box = function () {
var user = 'TT';
function run() { return '運行中...'; }
var desk = new Desk(); // 實例化自訂物件
desk.publicGo = function () {
return user + run();
};
return desk;
}();
alert(box.publicGo());
兩種寫法的差別在於「用來承載公開方法的載體」是物件字面量還是自訂物件的實例。前者更簡潔,是實務上的主流選擇;後者適合需要繼承或 instanceof 判斷的場景。
這是一個關鍵但常被誤解的細節:閉包中的 this 指向 window,而不是建立閉包的那個物件。
var user = 'The Window';
var obj = {
user: 'The Object',
getUserFunction: function () {
return function () {
return this.user; // 這個 this 是 window
};
}
};
document.writeln(obj.getUserFunction()()); // "The Window"
要讓內部函數存取外層物件的 this,實務上有三種做法:用一個 var self = this 把參照存下來;用 bind() 綁定 this;或改用箭頭函數,因為箭頭函數沒有自己的 this,會直接沿用外層的 this。
這批程式碼背後其實只有幾個核心概念:函數是物件所以能被賦值與傳遞;prototype 決定屬性是共享還是獨立;new 改變 this 的指向;而閉包讓內部函數保有對外部作用域的參照。把這四點想清楚,上面所有看似零散的技巧都會連成一條線。理解之後,多數場合都能用更簡潔的 ES6+ 語法(let/const、箭頭函數、class、解構)改寫得更清楚。