DIV CSS 佈局教程網

JavaScript 面向對象封裝特性的實例講解
編輯:關於JavaScript     

本文系統性地探討 JavaScript 中透過 prototype 實現對象封裝與共享的機制,並延伸到原型鏈、constructor 屬性以及 Object.create 等相關知識。

1. prototype 對象

1.1 構造函數的缺點

JavaScript 透過構造函數生成新對象,因此構造函數可視為對象的模板,實例對象的屬性和方法都可以定義在構造函數內部。

function Cat (name, color) {
    this.name = name;
    this.color = color;
}
var cat1 = new Cat('大毛', '白色');
cat1.name // '大毛'
cat1.color // '白色'

上面代碼的 Cat 函數是一個構造函數,內部定義了 name 和 color 屬性,所有實例都會生成這兩個屬性。但這樣做會浪費系統資源,因為同一構造函數的對象實例之間無法共享屬性。

function Cat(name, color) {
    this.name = name;
    this.color = color;
    this.meow = function () {
        console.log('mew, mew, mew...');
    };
}
var cat1 = new Cat('大毛', '白色');
var cat2 = new Cat('二毛', '黑色');
cat1.meow === cat2.meow // false

上面代碼中,cat1 和 cat2 是同一構造函數的實例,但它們的 meow 方法並不相同——每新建一個實例,就會新建一個 meow 方法。這既沒必要又浪費資源,因為所有 meow 方法行為相同,理應共享。

1.2 prototype 屬性的作用

在 JavaScript 中,每一個對象都有一個對應的原型對象,被稱為 prototype 對象。定義在原型對象上的所有屬性和方法,都能被派生對象繼承,這就是 JavaScript 繼承機制的基本設計。

構造函數是一個函數,同時也是一個對象,有自己的屬性和方法,其中 prototype 屬性指向另一個對象。只要定義在它上面的屬性和方法,就能被所有實例共享。也就是說,構造函數生成實例時,會自動為實例分配一個 prototype 屬性。

function Animal (name) {
    this.name = name;
}
Animal.prototype.color = "white";
var cat1 = new Animal('大毛');
var cat2 = new Animal('二毛');
cat1.color // 'white'
cat2.color // 'white'

更特別的是,只要修改 prototype 對象,變動會立刻體現在所有實例上。

Animal.prototype.color = "yellow";
cat1.color // 'yellow'
cat2.color // 'yellow'

這是因為實例本身並沒有 color 屬性,都是讀取 prototype 對象的 color。也就是說,當實例本身沒有某個屬性或方法時,它會到構造函數的 prototype 對象去尋找。反之,如果實例自身就有該屬性或方法,就不會再去 prototype 尋找。

cat1.color = 'black';
cat2.color // 'yellow'
Animal.prototype.color // "yellow";

總而言之,prototype 對象的作用就是定義所有實例共享的屬性和方法,因此它也被稱為實例對象的原型。

Animal.prototype.walk = function () {
    console.log(this.name + ' is walking.');
};

1.3 原型鏈

由於 JavaScript 的所有對象都有構造函數,而所有函數都有 prototype 屬性,所以所有對象都有自己的原型對象。一個對象的屬性和方法,可能定義在自身,也可能定義在原型對象上。由於原型本身也是對象,又有自己的原型,於是形成了一條原型鏈(prototype chain)。因為追根溯源,最源頭的對象都從 Object 構造函數生成,所以一層層上溯,所有對象的原型最終都可上溯到 Object.prototype,而 Object.prototype 的原型則是沒有任何屬性和方法的 null。

Object.getPrototypeOf(Object.prototype) // null

「原型鏈」的作用在於:當讀取對象的某個屬性時,JavaScript 引擎先尋找對象本身的屬性,找不到就到它的原型去找,還找不到就到原型的原型去找,以此類推,直到最頂層的 Object.prototype 仍找不到,則返回 undefined。

舉例來說,如果讓某個函數的 prototype 屬性指向一個數組,就意味著該函數可以作為數組的構造函數,因為它生成的實例都能透過 prototype 調用數組方法。

function MyArray (){}
MyArray.prototype = new Array();
MyArray.prototype.constructor = MyArray;
var mine = new MyArray();
mine.push(1, 2, 3);
mine.length // 3
mine instanceof Array // true

instanceof 運算符用來比較一個對象是否為某個構造函數的實例,它依次與實例對象的所有原型對象的 constructor 屬性進行比較,只要有一個符合就返回 true,否則返回 false。

1.4 constructor 屬性

prototype 對象有一個 constructor 屬性,默認指向 prototype 對象所在的構造函數。

function P() {}
P.prototype.constructor === P // true

由於 constructor 屬性定義在 prototype 對象上,意味著可以被所有實例繼承。

function P() {}
var p = new P();
p.constructor // function P() {}
p.constructor === P.prototype.constructor // true
p.hasOwnProperty('constructor') // false

constructor 屬性的作用是分辨 prototype 對象到底定義在哪個構造函數上面。

2. Object.getPrototypeOf 方法

Object.getPrototypeOf 方法返回一個對象的原型。

// 空對象的原型是 Object.prototype
Object.getPrototypeOf({}) === Object.prototype // true
// 函數的原型是 Function.prototype
function f() {}
Object.getPrototypeOf(f) === Function.prototype // true
// 假定 F 為構造函數,f 為 F 的實例對象,那麼 f 的原型是 F.prototype
var f = new F();
Object.getPrototypeOf(f) === F.prototype // true

3. Object.create 方法

Object.create 方法用於生成新的對象,可以替代 new 命令。它接受一個對象作為參數,返回一個新對象,後者完全繼承前者的屬性,即前者成為後者的原型。

var o1 = { p: 1 };
var o2 = Object.create(o1);
o2.p // 1

Object.create 方法基本等同於下面的代碼,如果老式浏覽器不支援,可自行部署:

if (typeof Object.create !== "function") {
    Object.create = function (o) {
        function F() {}
        F.prototype = o;
        return new F();
    };
}

下面三種方式生成的新對象是等價的。

var o1 = Object.create({});
var o2 = Object.create(Object.prototype);
var o3 = new Object();

如果想生成一個不繼承任何屬性的對象,可以將 Object.create 的參數設為 null。此外,它還可接受第二個參數,用於描述屬性的 attributes 對象。

var o = Object.create(Object.prototype, {
    p1: { value: 123, enumerable: true },
    p2: { value: "abc", enumerable: true }
});
o.p1 // 123
o.p2 // "abc"

4. isPrototypeOf 方法

isPrototypeOf 方法用來判斷一個對象是否是另一個對象的原型。只要某個對象處在原型鏈上,isPrototypeOf 都返回 true。

var o1 = {};
var o2 = Object.create(o1);
var o3 = Object.create(o2);
o2.isPrototypeOf(o3) // true
o1.isPrototypeOf(o3) // true

5. 一個簡單的封裝示例

var ClassDemo = function () {
    //靜態private變量
    var private_static_var = 'aaaa';
    //靜態private方法
    var private_static_func = function (key) {
        return key + private_static_var;
    }
    //private方法,關鍵就是第一參數self要傳入this
    var private_func = function (self, key) {
        return private_static_func(key + self.id);
    }
    var _class = function (id) {
        //構造函數
        this.id = id;
        //public變量
    }
    //public方法
    _class.prototype.public_func = function (key) {
        return private_func(this, key);
    }
    return _class;
}();
var a = new ClassDemo('hello world');
alert(a.public_func('world hello'));

JavaScript 沒有簡單的辦法實現 private 變量和 public 靜態變量/方法,不過封裝到這個程度已經夠用了。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved