1. 物件適合用來收集和管理資料,容易形成樹型結構。JavaScript 包含一個原型鏈特性,允許物件繼承另一個物件的屬性,正確使用它能減少物件的初始化時間和記憶體消耗。 2. 函式它們是 JavaScript 的基礎模組單元,用於程式碼復用、資訊隱藏和組合呼叫。函式用於指定物件的行為。一般來說,程式設計就是把一組需求分解成一組函式和資料結構的技能。 3. 模組我們可以使用函式和閉包來構造模組。模組是一個提供介面卻隱藏實作狀態和實作的函式或物件。
在基於類的系統中,物件是這樣定義的:使用類來描述它是什麼樣的。假如建築是基於類的系統,建築師會先畫出房子的藍圖,然後房子都按照藍圖來建造。
在使用自訂型別模式實現繼承時,我們只需把參數傳給構造函式,然後掛載在實例物件上;其他方法都不用傳參,因為透過實例物件呼叫的方法內部的 this 都能存取到該參數。掛載在實例 this 物件上的變數稱為實例變數。
function Person (name, age, job) {
this.name = name;
this.age = age;
this.job = job;
}
Person.prototype.sayName = function () {
alert(this.name);
}
var person1 = new Person('Nicholas', 29, 'Software Engineer');
var person2 = new Person('Greg', 27, 'Doctor');
function SuperType (name) {
this.name = name;
this.colors = ['red', 'blue', 'green'];
}
SuperType.prototype.sayName = function () {
console.log(this.name);
}
function SubType (name, age) {
SuperType.call(this, name); // 繼承屬性
this.age = age;
}
SubType.prototype = new SuperType(); // 繼承方法
SubType.prototype.sayAge = function () {
console.log(this.age)
}
在繼承屬性和方法時,我們一共呼叫了兩次超類構造函式。當透過 new 呼叫超類構造函式建立子類原型時,子類原型物件會成為超類的實例,因此也會有超類為實例 this 添加的屬性(值為 undefined),這就造成了浪費。我們真正需要的,只是讓子類原型繼承超類原型的方法。因此改進步驟是:
關於 constructor 屬性:它是構造器函式的原型上才有的屬性,指向該構造器;改寫過的原物件預設沒有 constructor 屬性。
function inheritPrototype (subType, superType) {
var prototype = Object.create(superType.prototype);
prototype.constructor = subType;
subType.prototype = prototype;
};
function SuperType (name) {
this.name = name;
this.colors = ['red', 'blue', 'green'];
}
SuperType.prototype.sayName = function () {
console.log(this.name);
}
function SubType(name, age) {
SuperType.call(this, name); // 繼承屬性
this.age = age;
}
inheritPrototype(SubType, SuperType); // 繼承方法
SubType.prototype.sayAge = function () {
console.log(this.age);
}
這種方式隱藏了 prototype 的操作細節,看起來不再那麼怪異,但它仍有明顯缺點:沒有私有環境,所有屬性都是公開的;無法存取父類的方法;難以除錯。
在一個純粹的原型模式中,我們會擯棄類,轉而專注於物件。基於原型的繼承相比基於類的繼承在概念上更簡單:一個新物件可以繼承一個舊物件的屬性。如果建築是基於原型的,建築師會先蓋一所房子,然後把其他房子都蓋成這種模樣。
Object.create() 作為 new 操作符的替代方案,使用它建立 JavaScript 物件時,能增添一種更貼近原型的感覺。
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) {
if (s) { s += '-'; }
s += 'r';
}
return s;
}
這是一種「差異化繼承」——透過定制一個新物件,指明它與所基於的基本物件的差異。它在某些資料結構繼承於其他資料結構的情形中非常有用。
在偽類模式中,構造器 Cat 不得不重複構造器 Mammal 已完成的工作。而在函數化模式中不再需要這樣,因為構造器 Cat 會呼叫構造器 Mammal,讓它完成大部分建立工作,Cat 只關注自身的差異即可。函數化模式有很大的靈活性,相比偽類模式工作更少,還帶來更好的封裝、資訊隱藏,以及存取父類方法的能力。
如果我們用函數化樣式建立物件,且該物件的所有方法都不用 this 或 that,那麼該物件就是「持久性」的——它是一個簡單功能函式的集合。
私有變數:任何在函式中定義的變數,都可以被視為私有變數,因為它們無法在函式外部存取。
閉包:閉包是阻止垃圾回收器把變數從記憶體中移除的方法,使得在建立變數的執行環境之外仍能存取該變數。閉包由函式建立,每次呼叫函式會建立一個唯一的執行環境物件;函式執行完後,執行物件會被丟棄,除非呼叫者引用了它。如果函式返回的是更複雜的結構(函式、物件或陣列)並被保存到變數上,就建立了對執行環境的引用。
Function.prototype.method = function (name, func) {
this.prototype[name] = func;
return this;
}
// 工廠 mammal 函式
var mammal = function (spec) {
var that = {};
that.get_name = function () {
return spec.name;
}
that.says = function () {
return spec.saying || '';
}
return that;
}
// 工廠 cat 函式(基於 mammal)
var cat = function (spec) {
spec.saying = spec.saying || 'meow';
var that = mammal(spec);
that.purr = function (n) {
var i, s = '';
for (i = 0; i < n; i += 1) {
if (s) { s += '-'; }
s += 'r';
}
return s;
}
that.get_name = function () {
return that.says() + ' ' + spec.name + ' ' + that.says();
}
return that;
}
// 建立 myCat 物件
var myCat = cat({name: 'Henrietta'});
如果物件的所有狀態都是私有的,那麼該物件就成為一個「防偽(tamper-proof)」物件。用函數式樣式建立、且所有方法都不使用 this 或 that 的物件,就是持久性物件——它不會被入侵,除非有方法授權,否則攻擊者無法存取物件內部狀態。
前面的模式用於為自訂型別建立私有變數和特權方法,而模組模式則是為單例建立私有變數和特權方法。所謂單例,就是只有一個實例的物件(用物件字面量表示法建立的物件)。
var singleton = function () {
// 私有變數和函式
var privateVariable = 10;
function privateFunction () {
return false;
}
// 特權/公有方法和屬性
return {
publicProperty: true,
publicMethod: function () {
privateVariable++;
return privateFunction();
}
}
}()
這個物件字面量定義的是單例的公共介面。這種模式在需要對單例進行某些初始化,同時又需要維護其私有變數時非常有用。
這種增強的模組模式適合那些單例必須是某種類型的實例,同時還要添加某些屬性和方法加以增強的情形。
var singleton = function () {
var privateVariable = 10;
function privateFunction () {
return false;
}
var object = new CustomType();
object.publicProperty = true;
object.publicMethod = function () {
privateVariable++;
return privateFunction();
}
return object;
}()