继承

概述

JavaScript语言的所有对象,都有自己的继承链。也就是说,每个对象都有一个上级对象,称为prototype对象(只有null除外,它没有自己的prototype对象)。上级对象的属性和方法,都可以从下级对象上获取。

ES5提供方法,可以读取当前对象的prototype对象,而没有提供改写它的标准方法。

var p = Object.getPrototypeOf(obj);

所以,ES5一般不改写prototype对象,而是重新生成一个新的对象。

var obj = Object.create(p);

但是,大多数浏览器都支持使用一个非标准的__proto__属性(前后各两个下划线),改写原型对象。

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

obj.__proto__ = p;
obj.__proto__ === p // true

上面代码通过__proto__属性,将p对象设为obj对象的原型。

下面是一个实际的例子。

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

上面代码中,b对象本身并没有x属性,但是JavaScript引擎通过__proto__属性,找到它的原型对象a,然后读取ax属性。

原型对象自己的__proto__属性,也可以指向其他对象,从而一级一级地形成“原型链”(prototype chain)。

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

c.x // 1

构造函数的继承

这个小节介绍,如何让一个构造函数,继承另一个构造函数。

假定有一个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); // 调用父类构造函数
}

// 子类继承父类的方法
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__ === o.constructor.prototype
// true

上面代码首先新建了一个对象obj,它的__proto__属性,指向构造函数(Objectobj.constructor)的prototype属性。所以,两者比较以后,返回true

因此,获取实例对象obj的原型对象,有三种方法。

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

第三种方法的用法如下。

var o = new Object();

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

可以使用Object.getPrototypeOf方法,检查浏览器是否支持__proto__属性,老式浏览器不支持这个属性。

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

上面代码将一个对象的__proto__属性设为null,然后使用Object.getPrototypeOf方法获取这个对象的原型,判断是否等于null。如果当前环境支持__proto__属性,两者的比较结果应该是true

有了__proto__属性,就可以很方便得设置实例对象的原型了。假定有三个对象machinevehiclecar,其中machinevehicle的原型,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方法。


Date.hasOwnProperty('length')
// true

Date.hasOwnProperty('toString')
// false

对象的继承属性

用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;
}

参考链接