每個函數建立時預設帶有一個 prototype 屬性,其中包含一個 constructor 屬性,以及一個指向 Object 物件的隱藏屬性 __proto__。constructor 的值就是該函數本身。
在一個函數前加上 new 呼叫,會建立一個隱式連接到該函數 prototype 的新物件(透過 __proto__ 鏈接),同時函數的 this 會被綁定到那個新物件上。
函數總是回傳一個值:沒指定回傳值時回傳 undefined;作為構造函數呼叫時,若回傳值不是物件,則回傳 this(該新物件);若回傳值是物件,則它會取代 this 成為 new 表達式的結果。
function A(){
this.p = 'haha';
return {p:'heihei'};
}
var a = new A();
alert(a.p); // "heihei",效果等同 var a = A();
這是一個容易忽略的細節:return 一個物件會讓構造函數對 this 的所有設定失效。
函數 A 內部直接呼叫函數 B 時,B 的 this 會綁定到全域物件,而不是它的外部函數 A。這是 JS 設計上的一個缺陷,只能繞過——通常在 A 中用一個變數(慣例命名為 that 或 self)保存 A 的 this 參考。
var obj = {
name: 'test',
run: function () {
var that = this; // 保存外層 this
setTimeout(function () {
console.log(that.name); // "test"
}, 0);
}
};
函數的 length 屬性表示定義時指定的形參數目。
arguments 則包含呼叫時傳入的所有參數,不管宣告中是否定義了對應形參。但要注意:arguments 不是陣列,只是一個「類陣列」物件(arguments instanceof Array 回傳 false)。要轉成真陣列,用 Array.prototype.slice.call(arguments)。
給函數原型加上方法,所有函數就都能用——包括 Object、Number 這些構造函數:
Function.prototype.method = function (name, func) {
this.prototype[name] = func;
return this;
};
於是可以用 Object.method(...) 為所有物件增加方法,用 Number.method(...) 為所有數值增加方法。注意此時 Object、Number 本身並沒有繼承 method(它們是 Function 的實例,不是 Object.prototype 的子孫),若要達到這個目的,需另外執行:
Object.method('method', Object.method);
Number.method('negative', function () {
return 0 - this;
});
呼叫時有個語法陷阱:數字後直接跟點號再呼叫方法是無效的,3.negative() 會被解析為浮點數字面量的嘗試。正確寫法有幾種:
(3).negative(); // 用小括號強制轉為表達式 3 .negative(); // 數字後加空格(n >= 1) var n = 3; n.negative(); // 定義變數 3['negative'](); // 用中括號取值
用函數表達式定義函數時,function 後面的名字可以在函數體內用來遞迴呼叫自己,且這個名字不會被外部覆蓋。
先看會出錯的宣告式寫法:
function a(n) {
if (n > 1) return a(n - 1) + 1;
else return 1;
}
var aa = a;
a = 1; // 把 a 改成整數
aa(3); // TypeError: Property 'a' of object [object Window] is not a function
遞迴已經被破壞,因為 a 的內部呼叫是動態查找外層的 a。解法有兩種:用 arguments.callee,或者改用具名函數表達式:
var b = function a(n) {
if (n > 1) return a(n - 1) + 1;
else return 1;
};
var bb = b;
a = 3;
bb(3); // 正確回傳
此時 bb 內部的 a 指向函數表達式自身的名字,不受外層同名變數影響。
要提高封裝性,可以用「回傳物件」的方式取代 prototype 繼承:
var funcCons = function (spec) {
var that = {};
that.getName = function () {
return spec.name;
};
that.says = function () {
return spec.saying || '';
};
return that;
};
var myFunc = funcCons({ name: 'NearEast' });
這種寫法的好處是可以在構造器中定義真正的私有變數與函數,不必全部暴露在 this 上。代價是每個實例都會複製一份方法,無法透過原型共享,記憶體開銷較大。
這些機制在 ES6 之後有了語法糖層的包裝,理解底層仍有價值,但日常開發建議直接用標準語法:
class FuncCons {
#spec; // 真正的私有欄位
constructor(spec) { this.#spec = spec; }
getName() { return this.#spec.name; }
says() { return this.#spec.saying || ''; }
}
const myFunc = new FuncCons({ name: 'NearEast' });
# 前綴的私有欄位是語言層級的保證,比閉包模擬更嚴格;class 內定義的方法則自動掛在原型上共享。理解 prototype 鏈能讓你知道這些語法糖背後發生了什麼,這才是讀原始碼與排查問題時真正的本錢。