本文假設你已有其他語言的程式設計經驗,重點放在 JavaScript 中最容易誤解的三個部分:物件的本質、原型鏈、以及 this 的綁定規則。
簡單型別有五種:數字、字串、布林(true/false)、null、undefined。其餘都是物件,包括函式、陣列、正則運算式與物件本身。
提醒:不要完全相信 typeof 的回傳值,例如 typeof null 會得到 "object",這是語言早期留下的歷史包袱。
在 JavaScript 中,物件就是「屬性的集合」,可視為關聯陣列。每個屬性包含:屬性名(必須為字串)與屬性值(除 undefined 外皆可)。
// 用物件字面量建立空物件
var empty_object = {};
var stooge = {
"first-name": "Jerome", // 含連字號,必須加引號
"last-name": "Howard"
};
// 屬性名若是合法識別符,可省略引號
var flight = {
airline: "Oceanic",
number: 815,
departure: { IATA: "SYD", time: "2004-09-22 14:55", city: "Sydney" },
arrival: { IATA: "LAX", time: "2004-09-23 10:42", city: "Los Angeles" }
};
屬性存取有兩種寫法,不存在的屬性回傳 undefined:
var owner = { name: "Name5566" };
owner.name; // "Name5566"
owner["name"]; // "Name5566"
owner.job; // undefined
owner.job = "coder";
關鍵觀念:物件是「以參照傳遞」而非複製:
var x = {};
var owner = x;
owner.name = "Name5566";
x.name; // "Name5566",兩者指向同一個物件
屬性可用 delete 移除:delete obj.x;
每個物件都被連結到一個原型物件,並能從原型繼承屬性。以物件字面量建立的物件,其原型是 Object.prototype(而它本身沒有原型)。
規則是:讀取屬性時,若自身沒有,就沿原型鏈往上找,直到 Object.prototype;但「修改」屬性時只會作用在自己身上,不會動到原型。這也是為什麼用 for...in 時常需要用 hasOwnProperty 過濾掉繼承來的多餘屬性。
函式連結到 Function.prototype,並擁有一個 prototype 屬性(型別為物件),其中的 constructor 指回函式本身:
var f = function() {};
typeof f.prototype; // 'object'
f === f.prototype.constructor; // true
函式有兩個隱藏屬性:它的上下文與它的程式碼。函式可以放進變數、陣列,可以當參數傳遞,也可以在函式內部定義函式。
var f = function add(a, b) { return a + b; }
console.log(f); // [Function: add]
function 後面的名稱是可選的,主要用於遞迴呼叫與除錯時的識別;沒有名稱的叫匿名函式。JavaScript 不要求實參與形式參數數量相符——多傳的被忽略,少傳的其值為 undefined;若沒有 return,回傳值就是 undefined。
函式與它所存取的外部變數共同構成閉包,這是 JavaScript 最關鍵的魅力所在。
每次呼叫時,函式會收到兩個額外參數:this 與 arguments。this 的值取決於「怎麼呼叫」,而非「在哪定義」。
函式作為物件屬性,透過 o.m(args) 呼叫時,this 就是 o:
var obj = {
value: 0,
increment: function(v) {
this.value += (typeof v === 'number' ? v : 1);
}
};
obj.increment(); // this === obj
不屬於任何物件的函式被直接呼叫時,this 會綁到全域物件:
message = 'Hello World';
var p = function() { console.log(this.message); };
p(); // 'Hello World'
這裡藏著一個經典陷阱:
obj = {
value: 0,
increment: function() {
var helper = function() {
this.value += 1; // 加到了全域物件上,不是 obj
};
helper(); // 以函式模式呼叫
}
};
obj.increment();
obj.value; // 仍是 0
解法是在方法內先用一個變數接住 this:
obj = {
value: 0,
increment: function() {
var that = this;
var helper = function() { that.value += 1; };
helper();
}
};
obj.increment();
obj.value; // 1
(在 ES5 以後,箭頭函式因為不綁定自己的 this,能直接繼承外層的值,是更現代的寫法。)
以 new 呼叫的函式被稱為建構函式(慣例上首字大寫)。new 會建立一個連結到該函式 prototype 的新物件,並讓函式內的 this 指向它:
var Test = function(string) { this.message = string; };
var myTest = new Test("Hello World");
apply 的第一個參數指定 this,第二個是參數陣列:
var add = function(a, b) { return a + b; };
var ret = add.apply(null, [3, 4]); // 7
呼叫時可存取名為 arguments 的類陣列(不是真正的陣列),內含所有實參,因此能實作變長參數:
var add = function() {
var sum = 0;
for (var i = 0; i < arguments.length; ++i) sum += arguments[i];
return sum;
};
add(1, 2, 3, 4); // 10
var add = function (a, b) {
if (typeof a !== 'number' || typeof b !== 'number') {
throw { name: 'TypeError', message: 'add needs numbers' };
}
return a + b;
};
try {
add("seven");
} catch (e) {
console.log(e.name + ': ' + e.message);
}
實務上建議丟出真正的 Error 物件(throw new TypeError(...)),才能保有完整的堆疊資訊。
大多數型別都有對應的建構函式(Object、Array、Function、String、Number、Boolean、RegExp),因此可以往其 prototype 上掛方法:
Number.prototype.integer = function() {
return Math[this < 0 ? 'ceil' : 'floor'](this);
};
(1.1).integer(); // 1
但要謹慎:擴充內建原型會影響整份頁面所有程式碼,若與第三方函式庫命名衝突,排查起來非常痛苦。除 polyfill 之外,盡量不要這麼做。
JavaScript 需要用函式來建立作用域:
(function() {
// ...
})();
利用這點可以隱藏不希望外露的變數:
var obj = function() {
var value = 0; // 外部無法存取
return {
increment: function() { value += 1; },
getValue: function() { return value; }
};
}();
obj.increment();
obj.getValue(); // 1
建立物件時可以指定其原型:
var o = Object.create({x:1, y:2});
Object.create 定義於 ECMAScript 5,若要在 ES3 環境使用可自行補上:
if (typeof Object.create !== 'function') {
Object.create = function (o) {
var F = function () {};
F.prototype = o;
return new F();
};
}
原型式繼承的範例——新物件直接繼承舊物件,不需要「類」的存在:
var myMammal = {
name: 'Herb the Mammal',
get_name: function() { return this.name; },
says: function() { return this.saying || ''; }
};
var myCat = Object.create(myMammal);
myCat.name = 'Henrietta';
myCat.saying = 'meow';
myCat.purr = function(n) {
var i, s = '';
for (i = 0; i < n; i += 1) s += (s ? '-' : '') + 'r';
return s;
};
這種寫法簡單,但無法保護私有成員。若需要私有性,改用模組模式——由函式產生物件,並靠函式作用域把私有資料藏起來:
var mammal = function(spec) {
var that = {};
that.get_name = function() { return spec.name; }; // spec.name 外部無法直接存取
that.says = function() { return spec.saying || ''; };
return that;
};
var myMammal = mammal({name: 'Herb'});
var cat = function(spec) {
spec.saying = spec.saying || 'meow';
var that = mammal(spec); // 先構造出 mammal,即完成繼承
that.purr = function(n) {
var i, s = '';
for (i = 0; i < n; i += 1) s += (s ? '-' : '') + 'r';
return s;
};
that.get_name = function() {
return that.says() + ' ' + spec.name + ' ' + that.says();
};
return that;
};
var myCat = cat({name: 'Henrietta'});
在模組模式中,繼承是透過「呼叫建構函式」完成的。若想被子類存取父類的方法,可以加上一個輔助:
Object.prototype.superior = function(name) {
var that = this, method = that[name];
return function() { return method.apply(that, arguments); };
};
var coolcat = function (spec) {
var that = cat(spec), super_get_name = that.superior('get_name');
that.get_name = function(n) {
return 'like ' + super_get_name() + ' baby';
};
return that;
};
最後補一句現實面的建議:今天的專案幾乎都會用 ES6 以後的 class/extends 語法糖與箭頭函式,that = this 這種繞法已很少需要。但理解上述四種呼叫模式,才能解釋 this 為什麼在某些回呼中「跑掉」——這是除錯時的必備知識。