DIV CSS 佈局教程網

 DIV+CSS佈局教程網 >> 網頁腳本 >> JavaScript入門知識 >> JavaScript基礎知識 >> JavaScript程序中實現繼承特性的方式總結
JavaScript程序中實現繼承特性的方式總結
編輯:JavaScript基礎知識     

概述
JavaScript的所有對象,都有自己的繼承鏈。也就是說,每個對象都繼承另一個對象,該對象稱為“原型”(prototype)對象。只有null除外,它沒有自己的原型對象。

原型對象的重要性在於,如果A對象是B對象的原型,那麼B對象可以拿到A對象的所有屬性和方法。Object.getPrototypof方法用於獲取當前對象的原型對象。

var p = Object.getPrototypeOf(obj);

上面代碼中,對象p就是對象obj的原型對象。

Object.create方法用於生成一個新的對象,繼承指定對象。

var obj = Object.create(p);

上面代碼中,新生成的obj對象的原型就是對象p。

非標准的__proto__屬性(前後各兩個下劃線),可以改寫某個對象的原型對象。但是,應該盡量少用這個屬性,而是用Object.getPrototypeof()和Object.setPrototypeOf(),進行原型對象的讀寫操作。

var obj = {};
var p = {};

obj.__proto__ = p;
Object.getPrototypeOf(obj) === p // true

上面代碼通過__proto__屬性,將p對象設為obj對象的原型。

下面是一個實際的例子。

var a = {x: 1};
var b = {__proto__: a};
b.x // 1

上面代碼中,b對象通過__proto__屬性,將自己的原型對象設為a對象,因此b對象可以拿到a對象的所有屬性和方法。b對象本身並沒有x屬性,但是JavaScript引擎通過__proto__屬性,找到它的原型對象a,然後讀取a的x屬性。

new命令通過構造函數新建實例對象,實質就是將實例對象的原型綁定構造函數的prototype屬性,然後在實例對象上執行構造函數。

var o = new Foo();

// 等同於
var o = new Object();
o.__proto__ = Foo.prototype;
Foo.call(o);

原型對象自己的__proto__屬性,也可以指向其他對象,從而一級一級地形成“原型鏈”(prototype chain)。

var a = { x: 1 };
var b = { __proto__: a };
var c = { __proto__: b };

c.x // 1

需要注意的是,一級級向上,在原型鏈尋找某個屬性,對性能是有影響的。所尋找的屬性在越上層的原型對象,對性能的影響越大。如果尋找某個不存在的屬性,將會遍歷整個原型鏈。

this的動作指向
不管this在哪裡定義,使用的時候,它總是指向當前對象,而不是原型對象。

var o = {
 a: 2,
 m: function(b) {
  return this.a + 1;
 }
};

var p = Object.create(o);
p.a = 12;

p.m() // 13

上面代碼中,p對象的m方法來自它的原型對象o。這時,m方法內部的this對象,不指向o,而是指向p。

構造函數的繼承
這個小節介紹,如何讓一個構造函數,繼承另一個構造函數。

假定有一個Shape構造函數。

function Shape() {
 this.x = 0;
 this.y = 0;
}

Shape.prototype.move = function (x, y) {
 this.x += x;
 this.y += y;
 console.info('Shape moved.');
};
Rectangle構造函數繼承Shape。

function Rectangle() {
 Shape.call(this); // 調用父類構造函數
}
// 另一種寫法
function Rectangle() {
 this.base = Shape;
 this.base();
}

// 子類繼承父類的方法
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;

var rect = new Rectangle();

rect instanceof Rectangle // true
rect instanceof Shape // true

rect.move(1, 1) // 'Shape moved.'

上面代碼表示,構造函數的繼承分成兩部分,一部分是子類調用父類的構造方法,另一部分是子類的原型指向父類的原型。

上面代碼中,子類是整體繼承父類。有時,只需要單個方法的繼承,這時可以采用下面的寫法。

ClassB.prototype.print = function() {
 ClassA.prototype.print.call(this);
 // some code
}

上面代碼中,子類B的print方法先調用父類A的print方法,再部署自己的代碼。這就等於繼承了父類A的print方法。

__proto__屬性
__proto__屬性指向當前對象的原型對象,即構造函數的prototype屬性。

var obj = new Object();

obj.__proto__ === Object.prototype
// true
obj.__proto__ === obj.constructor.prototype
// true

上面代碼首先新建了一個對象obj,它的__proto__屬性,指向構造函數(Object或obj.constructor)的prototype屬性。所以,兩者比較以後,返回true。

因此,獲取實例對象obj的原型對象,有三種方法。

  • obj.__proto__
  • obj.constructor.prototype
  • Object.getPrototypeOf(obj)

上面三種方法之中,前兩種都不是很可靠。最新的ES6標准規定,__proto__屬性只有浏覽器才需要部署,其他環境可以不部署。而obj.constructor.prototype在手動改變原型對象時,可能會失效。

var P = function () {};
var p = new P();

var C = function () {};
C.prototype = p;
var c = new C();

c.constructor.prototype === p // false

上面代碼中,C構造函數的原型對象被改成了p,結果c.constructor.prototype就失真了。所以,在改變原型對象時,一般要同時設置constructor屬性。

C.prototype = p;
C.prototype.constructor = C;

c.constructor.prototype === p // true

所以,推薦使用第三種Object.getPrototypeOf方法,獲取原型對象。該方法的用法如下。

var o = new Object();

Object.getPrototypeOf(o) === Object.prototype
// true

可以使用Object.getPrototypeOf方法,檢查浏覽器是否支持__proto__屬性,老式浏覽器不支持這個屬性。

Object.getPrototypeOf({ __proto__: null }) === null

上面代碼將一個對象的__proto__屬性設為null,然後使用Object.getPrototypeOf方法獲取這個對象的原型,判斷是否等於null。如果當前環境支持__proto__屬性,兩者的比較結果應該是true。

有了__proto__屬性,就可以很方便得設置實例對象的原型了。假定有三個對象machine、vehicle和car,其中machine是vehicle的原型,vehicle又是car的原型,只要兩行代碼就可以設置。

vehicle.__proto__ = machine;
car.__proto__ = vehicle;

下面是一個實例,通過__proto__屬性與constructor.prototype屬性兩種方法,分別讀取定義在原型對象上的屬性。

Array.prototype.p = 'abc';
var a = new Array();

a.__proto__.p // abc
a.constructor.prototype.p // abc

顯然,__proto__看上去更簡潔一些。

通過構造函數生成實例對象時,實例對象的__proto__屬性自動指向構造函數的prototype對象。

var f = function (){};
var a = {};

f.prototype = a;
var o = new f();

o.__proto__ === a
// true

屬性的繼承
屬性分成兩種。一種是對象自身的原生屬性,另一種是繼承自原型的繼承屬性。

對象的原生屬性
對象本身的所有屬性,可以用Object.getOwnPropertyNames方法獲得。

Object.getOwnPropertyNames(Date)
// ["parse", "arguments", "UTC", "caller", "name", "prototype", "now", "length"]

對象本身的屬性之中,有的是可以枚舉的(enumerable),有的是不可以枚舉的。只獲取那些可以枚舉的屬性,使用Object.keys方法。

Object.keys(Date) // []
hasOwnProperty()

hasOwnProperty方法返回一個布爾值,用於判斷某個屬性定義在對象自身,還是定義在原型鏈上。

Date.hasOwnProperty('length')
// true

Date.hasOwnProperty('toString')
// false

hasOwnProperty方法是JavaScript之中唯一一個處理對象屬性時,不會遍歷原型鏈的方法。

對象的繼承屬性
用Object.create方法創造的對象,會繼承所有原型對象的屬性。

var proto = { p1: 123 };
var o = Object.create(proto);

o.p1 // 123
o.hasOwnProperty("p1") // false

獲取所有屬性
判斷一個對象是否具有某個屬性(不管是自身的還是繼承的),使用in運算符。

"length" in Date // true
"toString" in Date // true

獲得對象的所有可枚舉屬性(不管是自身的還是繼承的),可以使用for-in循環。

var o1 = {p1: 123};

var o2 = Object.create(o1,{
 p2: { value: "abc", enumerable: true }
});

for (p in o2) {console.info(p);}
// p2
// p1

為了在for...in循環中獲得對象自身的屬性,可以采用hasOwnProperty方法判斷一下。

for ( var name in object ) {
 if ( object.hasOwnProperty(name) ) {
  /* loop code */
 }
}

獲得對象的所有屬性(不管是自身的還是繼承的,以及是否可枚舉),可以使用下面的函數。

function inheritedPropertyNames(obj) {
 var props = {};
 while(obj) {
  Object.getOwnPropertyNames(obj).forEach(function(p) {
   props[p] = true;
  });
  obj = Object.getPrototypeOf(obj);
 }
 return Object.getOwnPropertyNames(props);
}

用法如下:

inheritedPropertyNames(Date)
// ["caller", "constructor", "toString", "UTC", "call", "parse", "prototype", "__defineSetter__", "__lookupSetter__", "length", "arguments", "bind", "__lookupGetter__", "isPrototypeOf", "toLocaleString", "propertyIsEnumerable", "valueOf", "apply", "__defineGetter__", "name", "now", "hasOwnProperty"]

對象的拷貝
如果要拷貝一個對象,需要做到下面兩件事情。

確保拷貝後的對象,與原對象具有同樣的prototype原型對象。
確保拷貝後的對象,與原對象具有同樣的屬性。
下面就是根據上面兩點,編寫的對象拷貝的函數。

function copyObject(orig) {
 var copy = Object.create(Object.getPrototypeOf(orig));
 copyOwnPropertiesFrom(copy, orig);
 return copy;
}

function copyOwnPropertiesFrom(target, source) {
 Object
 .getOwnPropertyNames(source)
 .forEach(function(propKey) {
  var desc = Object.getOwnPropertyDescriptor(source, propKey);
  Object.defineProperty(target, propKey, desc);
 });
 return target;
}

多重繼承
JavaScript不提供多重繼承功能,即不允許一個對象同時繼承多個對象。但是,可以通過變通方法,實現這個功能。

function M1(prop) {
 this.hello = prop;
}

function M2(prop) {
 this.world = prop;
}

function S(p1, p2) {
 this.base1 = M1;
 this.base1(p1);
 this.base2 = M2;
 this.base2(p2);
}
S.prototype = new M1();

var s = new S(111, 222);
s.hello // 111
s.world // 222

上面代碼中,子類S同時繼承了父類M1和M2。當然,從繼承鏈來看,S只有一個父類M1,但是由於在S的實例上,同時執行M1和M2的構造函數,所以它同時繼承了這兩個類的方法。

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