Object 对象的相关方法

JavaScript 在Object对象上面,提供了很多相关方法,处理面向对象编程的相关操作。本章介绍这些方法。

Object.getPrototypeOf()

Object.getPrototypeOf方法返回参数对象的原型。这是获取原型对象的标准方法。

  1. var F = function () {};
  2. var f = new F();
  3. Object.getPrototypeOf(f) === F.prototype // true

上面代码中,实例对象f的原型是F.prototype

下面是几种特殊对象的原型。

  1. // 空对象的原型是 Object.prototype
  2. Object.getPrototypeOf({}) === Object.prototype // true
  3. // Object.prototype 的原型是 null
  4. Object.getPrototypeOf(Object.prototype) === null // true
  5. // 函数的原型是 Function.prototype
  6. function f() {}
  7. Object.getPrototypeOf(f) === Function.prototype // true

Object.setPrototypeOf()

Object.setPrototypeOf方法为参数对象设置原型,返回该参数对象。它接受两个参数,第一个是现有对象,第二个是原型对象。

  1. var a = {};
  2. var b = {x: 1};
  3. Object.setPrototypeOf(a, b);
  4. Object.getPrototypeOf(a) === b // true
  5. a.x // 1

上面代码中,Object.setPrototypeOf方法将对象a的原型,设置为对象b,因此a可以共享b的属性。

new命令可以使用Object.setPrototypeOf方法模拟。

  1. var F = function () {
  2. this.foo = 'bar';
  3. };
  4. var f = new F();
  5. // 等同于
  6. var f = Object.setPrototypeOf({}, F.prototype);
  7. F.call(f);

上面代码中,new命令新建实例对象,其实可以分成两步。第一步,将一个空对象的原型设为构造函数的prototype属性(上例是F.prototype);第二步,将构造函数内部的this绑定这个空对象,然后执行构造函数,使得定义在this上面的方法和属性(上例是this.foo),都转移到这个空对象上。

Object.create()

生成实例对象的常用方法是,使用new命令让构造函数返回一个实例。但是很多时候,只能拿到一个实例对象,它可能根本不是由构建函数生成的,那么能不能从一个实例对象,生成另一个实例对象呢?

JavaScript 提供了Object.create方法,用来满足这种需求。该方法接受一个对象作为参数,然后以它为原型,返回一个实例对象。该实例完全继承原型对象的属性。

  1. // 原型对象
  2. var A = {
  3. print: function () {
  4. console.log('hello');
  5. }
  6. };
  7. // 实例对象
  8. var B = Object.create(A);
  9. Object.getPrototypeOf(B) === A // true
  10. B.print() // hello
  11. B.print === A.print // true

上面代码中,Object.create方法以A对象为原型,生成了B对象。B继承了A的所有属性和方法。

实际上,Object.create方法可以用下面的代码代替。

  1. if (typeof Object.create !== 'function') {
  2. Object.create = function (obj) {
  3. function F() {}
  4. F.prototype = obj;
  5. return new F();
  6. };
  7. }

上面代码表明,Object.create方法的实质是新建一个空的构造函数F,然后让F.prototype属性指向参数对象obj,最后返回一个F的实例,从而实现让该实例继承obj的属性。

下面三种方式生成的新对象是等价的。

  1. var obj1 = Object.create({});
  2. var obj2 = Object.create(Object.prototype);
  3. var obj3 = new Object();

如果想要生成一个不继承任何属性(比如没有toStringvalueOf方法)的对象,可以将Object.create的参数设为null

  1. var obj = Object.create(null);
  2. obj.valueOf()
  3. // TypeError: Object [object Object] has no method 'valueOf'

上面代码中,对象obj的原型是null,它就不具备一些定义在Object.prototype对象上面的属性,比如valueOf方法。

使用Object.create方法的时候,必须提供对象原型,即参数不能为空,或者不是对象,否则会报错。

  1. Object.create()
  2. // TypeError: Object prototype may only be an Object or null
  3. Object.create(123)
  4. // TypeError: Object prototype may only be an Object or null

Object.create方法生成的新对象,动态继承了原型。在原型上添加或修改任何方法,会立刻反映在新对象之上。

  1. var obj1 = { p: 1 };
  2. var obj2 = Object.create(obj1);
  3. obj1.p = 2;
  4. obj2.p // 2

上面代码中,修改对象原型obj1会影响到实例对象obj2

除了对象的原型,Object.create方法还可以接受第二个参数。该参数是一个属性描述对象,它所描述的对象属性,会添加到实例对象,作为该对象自身的属性。

  1. var obj = Object.create({}, {
  2. p1: {
  3. value: 123,
  4. enumerable: true,
  5. configurable: true,
  6. writable: true,
  7. },
  8. p2: {
  9. value: 'abc',
  10. enumerable: true,
  11. configurable: true,
  12. writable: true,
  13. }
  14. });
  15. // 等同于
  16. var obj = Object.create({});
  17. obj.p1 = 123;
  18. obj.p2 = 'abc';

Object.create方法生成的对象,继承了它的原型对象的构造函数。

  1. function A() {}
  2. var a = new A();
  3. var b = Object.create(a);
  4. b.constructor === A // true
  5. b instanceof A // true

上面代码中,b对象的原型是a对象,因此继承了a对象的构造函数A

Object.prototype.isPrototypeOf()

实例对象的isPrototypeOf方法,用来判断该对象是否为参数对象的原型。

  1. var o1 = {};
  2. var o2 = Object.create(o1);
  3. var o3 = Object.create(o2);
  4. o2.isPrototypeOf(o3) // true
  5. o1.isPrototypeOf(o3) // true

上面代码中,o1o2都是o3的原型。这表明只要实例对象处在参数对象的原型链上,isPrototypeOf方法都返回true

  1. Object.prototype.isPrototypeOf({}) // true
  2. Object.prototype.isPrototypeOf([]) // true
  3. Object.prototype.isPrototypeOf(/xyz/) // true
  4. Object.prototype.isPrototypeOf(Object.create(null)) // false

上面代码中,由于Object.prototype处于原型链的最顶端,所以对各种实例都返回true,只有直接继承自null的对象除外。

Object.prototype.__proto__

实例对象的__proto__属性(前后各两个下划线),返回该对象的原型。该属性可读写。

  1. var obj = {};
  2. var p = {};
  3. obj.__proto__ = p;
  4. Object.getPrototypeOf(obj) === p // true

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

根据语言标准,__proto__属性只有浏览器才需要部署,其他环境可以没有这个属性。它前后的两根下划线,表明它本质是一个内部属性,不应该对使用者暴露。因此,应该尽量少用这个属性,而是用Object.getPrototypeOf()Object.setPrototypeOf(),进行原型对象的读写操作。

原型链可以用__proto__很直观地表示。

  1. var A = {
  2. name: '张三'
  3. };
  4. var B = {
  5. name: '李四'
  6. };
  7. var proto = {
  8. print: function () {
  9. console.log(this.name);
  10. }
  11. };
  12. A.__proto__ = proto;
  13. B.__proto__ = proto;
  14. A.print() // 张三
  15. B.print() // 李四
  16. A.print === B.print // true
  17. A.print === proto.print // true
  18. B.print === proto.print // true

上面代码中,A对象和B对象的原型都是proto对象,它们都共享proto对象的print方法。也就是说,ABprint方法,都是在调用proto对象的print方法。

获取原型对象方法的比较

如前所述,__proto__属性指向当前对象的原型对象,即构造函数的prototype属性。

  1. var obj = new Object();
  2. obj.__proto__ === Object.prototype
  3. // true
  4. obj.__proto__ === obj.constructor.prototype
  5. // true

上面代码首先新建了一个对象obj,它的__proto__属性,指向构造函数(Objectobj.constructor)的prototype属性。

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

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

上面三种方法之中,前两种都不是很可靠。__proto__属性只有浏览器才需要部署,其他环境可以不部署。而obj.constructor.prototype在手动改变原型对象时,可能会失效。

  1. var P = function () {};
  2. var p = new P();
  3. var C = function () {};
  4. C.prototype = p;
  5. var c = new C();
  6. c.constructor.prototype === p // false

上面代码中,构造函数C的原型对象被改成了p,但是实例对象的c.constructor.prototype却没有指向p。所以,在改变原型对象时,一般要同时设置constructor属性。

  1. C.prototype = p;
  2. C.prototype.constructor = C;
  3. var c = new C();
  4. c.constructor.prototype === p // true

因此,推荐使用第三种Object.getPrototypeOf方法,获取原型对象。

Object.getOwnPropertyNames()

Object.getOwnPropertyNames方法返回一个数组,成员是参数对象本身的所有属性的键名,不包含继承的属性键名。

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

上面代码中,Object.getOwnPropertyNames方法返回Date所有自身的属性名。

对象本身的属性之中,有的是可以遍历的(enumerable),有的是不可以遍历的。Object.getOwnPropertyNames方法返回所有键名,不管是否可以遍历。只获取那些可以遍历的属性,使用Object.keys方法。

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

上面代码表明,Date对象所有自身的属性,都是不可以遍历的。

Object.prototype.hasOwnProperty()

对象实例的hasOwnProperty方法返回一个布尔值,用于判断某个属性定义在对象自身,还是定义在原型链上。

  1. Date.hasOwnProperty('length') // true
  2. Date.hasOwnProperty('toString') // false

上面代码表明,Date.length(构造函数Date可以接受多少个参数)是Date自身的属性,Date.toString是继承的属性。

另外,hasOwnProperty方法是 JavaScript 之中唯一一个处理对象属性时,不会遍历原型链的方法。

in 运算符和 for…in 循环

in运算符返回一个布尔值,表示一个对象是否具有某个属性。它不区分该属性是对象自身的属性,还是继承的属性。

  1. 'length' in Date // true
  2. 'toString' in Date // true

in运算符常用于检查一个属性是否存在。

获得对象的所有可遍历属性(不管是自身的还是继承的),可以使用for...in循环。

  1. var o1 = { p1: 123 };
  2. var o2 = Object.create(o1, {
  3. p2: { value: "abc", enumerable: true }
  4. });
  5. for (p in o2) {
  6. console.info(p);
  7. }
  8. // p2
  9. // p1

上面代码中,对象o2p2属性是自身的,p1属性是继承的。这两个属性都会被for...in循环遍历。

为了在for...in循环中获得对象自身的属性,可以采用hasOwnProperty方法判断一下。

  1. for ( var name in object ) {
  2. if ( object.hasOwnProperty(name) ) {
  3. /* loop code */
  4. }
  5. }

获得对象的所有属性(不管是自身的还是继承的,也不管是否可枚举),可以使用下面的函数。

  1. function inheritedPropertyNames(obj) {
  2. var props = {};
  3. while(obj) {
  4. Object.getOwnPropertyNames(obj).forEach(function(p) {
  5. props[p] = true;
  6. });
  7. obj = Object.getPrototypeOf(obj);
  8. }
  9. return Object.getOwnPropertyNames(props);
  10. }

上面代码依次获取obj对象的每一级原型对象“自身”的属性,从而获取obj对象的“所有”属性,不管是否可遍历。

下面是一个例子,列出Date对象的所有属性。

  1. inheritedPropertyNames(Date)
  2. // [
  3. // "caller",
  4. // "constructor",
  5. // "toString",
  6. // "UTC",
  7. // ...
  8. // ]

对象的拷贝

如果要拷贝一个对象,需要做到下面两件事情。

  • 确保拷贝后的对象,与原对象具有同样的原型。
  • 确保拷贝后的对象,与原对象具有同样的实例属性。

下面就是根据上面两点,实现的对象拷贝函数。

  1. function copyObject(orig) {
  2. var copy = Object.create(Object.getPrototypeOf(orig));
  3. copyOwnPropertiesFrom(copy, orig);
  4. return copy;
  5. }
  6. function copyOwnPropertiesFrom(target, source) {
  7. Object
  8. .getOwnPropertyNames(source)
  9. .forEach(function (propKey) {
  10. var desc = Object.getOwnPropertyDescriptor(source, propKey);
  11. Object.defineProperty(target, propKey, desc);
  12. });
  13. return target;
  14. }

另一种更简单的写法,是利用 ES2017 才引入标准的Object.getOwnPropertyDescriptors方法。

  1. function copyObject(orig) {
  2. return Object.create(
  3. Object.getPrototypeOf(orig),
  4. Object.getOwnPropertyDescriptors(orig)
  5. );
  6. }

参考链接