JavaScript 沒有類的概念,創建對象時沒有固定模板,可以在運行時動態添加屬性和方法。理解這一點,是掌握這個語言的起點。
最樸素的創建方式是先 new 一個空對象,再逐個掛屬性:
var Programmer = new Object();
Programmer.name = "Young";
Programmer.age = 25;
alert(Programmer.name + " : " + Programmer.age);
JavaScript 對象與 C#、VB 的對象完全不同,它更接近 .NET 中的 Dictionary 類——一組鍵/值對的集合。因此除了點運算符,還可以用方括號訪問:
var Programmer = new Object();
Programmer["name"] = "Young";
Programmer["age"] = 25;
document.getElementById("message").innerHTML =
Programmer["name"] + " : " + Programmer["age"];
alert(Programmer.name + " : " + Programmer.age);
兩種寫法完全等價。訪問不存在的屬性會得到 undefined,而不會報錯。
把函數作為值掛上去,就成了對象的方法:
var Programmer = new Object();
Programmer["name"] = "Young";
Programmer.age = 25;
Programmer.speak = function () {
alert(this.name + " : " + this["age"]);
};
Programmer.speak();
交替使用 . 和 [] 雖然可行,但在表達意圖上顯得含糊——很難一眼看出對象從哪裡開始、到哪裡結束。字面量語法解決了這個問題:
var Programmer = {
name: "Young",
age: 25,
speak: function () {
alert(this.name + " : " + this.age);
}
};
Programmer.speak();
字面量還可以嵌套:
var Programmer = {
Figure: { name: "Young", age: 25 },
Company: { name: "Arcadia", address: "ShenZheng" },
speak: function () {
alert("name:" + this.Figure.name
+ "\nage:" + this.Figure.age
+ "\nCompany:" + this.Company.name + " of " + this.Company.address);
}
};
Programmer.speak();
這種語法因為意圖清晰、結構緊湊而廣受歡迎,你可以在各種 JavaScript 框架中看到它,包括目前廣泛使用的數據交換格式 JSON(JavaScript Object Notation)。JSON 是一種輕量級的數據交換格式,易於機器解析和生成,語法也更嚴格。我們可以用 eval 把 JSON 字符串轉為本地對象(現在應改用 JSON.parse,避免 eval 帶來的注入風險):
var Programmer = "({name: 'Young', age: 25})";
var p = JSON.parse(Programmer);
alert(p.name + ',' + p.age);
在 JavaScript 中,函數本身就是對象,這一點與 C# 的方法截然不同。
function add(point1, point2) {
var result = {
x: point1.x + point2.x,
y: point1.y + point2.y
};
return result;
}
var p1 = { x: 1, y: 1 };
var p2 = { x: 2, y: 2 };
var p3 = add(p1, p2);
alert(p3.x + "," + p3.y);
把函數作為屬性值,就成了對象的方法:
var Boy = {
name: "Young",
Love: function (Girl) {
return this.name + " 愛上了 " + Girl.name;
}
};
var Girl = { name: "Jing" };
alert(Boy.Love(Girl));
問題隨之而來:Girl 沒有 Love 方法,因為我們只是各自 new 了兩個對象,並沒有類似 C# 的類來統一它們的結構。如果希望多個對象共享同一套方法,可以先定義一個獨立函數再掛上去:
function LoveRelation(person) {
alert(this.name + " 愛上了 " + person.name);
}
var person1 = { name: "Young", Love: LoveRelation };
var person2 = { name: "Jing", Love: LoveRelation };
person1.Love(person2);
這看起來像是想創建一個 Person 類並實例化兩次,但顯然不夠優雅。有兩種更好的途徑。
function Person(n) {
this.name = n;
this.Love = function (person) {
alert(this.name + " 愛上了 " + person.name);
};
}
var person1 = new Person("Young");
var person2 = new Person("Jing");
person1.Love(person2);
缺點很明顯:每 new 一次,Love 函數都會重新創建一份,浪費內存。
function Person(n) {
this.name = n;
}
Person.prototype.Love = function (person) {
alert(this.name + " 愛上了 " + person.name);
};
var person1 = new Person("Young");
var person2 = new Person("Jing");
person1.Love(person2);
person2.Love(person1);
這裡 Person 函數相當於構造器,所有通過它構造出的對象共用同一個 prototype,方法只存在一份。這也是後來 ES6 class 語法糖背後的實現機制。
Douglas Crockford 在 Private Members In JavaScript 中詳細演示了如何創建私有成員。核心思想是:利用閉包,把構造函數的參數隱藏起來,只通過 getter/setter 暴露訪問:
function Point(x, y) {
this.get_x = function () { return x; };
this.set_x = function (value) { x = value; };
this.get_y = function () { return y; };
this.set_y = function (value) { y = value; };
}
Point.prototype.print = function () {
return this.get_x() + ',' + this.get_y();
};
var p = new Point(2, 2);
p.set_x(4);
alert(p.print());
外部無法直接讀寫 x 和 y,只能經過方法,這就實現了封裝。
命名空間可以避免同名類型之間的衝突,學過 C# 的朋友對此一定很熟悉。在 JavaScript 中,用一個對象當容器即可:
var Arcadia = {};
Arcadia.Person = function (n) {
this.name = n;
};
Arcadia.Person.prototype.Love = function (person) {
alert(this.name + " 愛上了 " + person.name);
};
var person1 = new Arcadia.Person("Young");
var person2 = new Arcadia.Person("Jing");
person1.Love(person2);
大型項目中通常會用更嚴謹的方式確保命名空間存在(例如 var App = App || {};),並配合模塊模式或 ES Module 來管理依賴,避免全局污染。