Object 对象的相关方法

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

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

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

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

    Object.setPrototypeOf()

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

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

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

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

    1. var F = function () {
    2.   this.foo = 'bar';
    3. };
    5. var f = new F();
    6. // 等同于
    7. var f = Object.setPrototypeOf({}, F.prototype);
    8. 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. };
    8. // 实例对象
    9. var B = Object.create(A);
    11. Object.getPrototypeOf(B) === A // true
    12. B.print() // hello
    13. 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();

    如果想要生成一个不继承任何属性（比如没有toString和valueOf方法）的对象，可以将Object.create的参数设为null。

    1. var obj = Object.create(null);
    3. obj.valueOf()
    4. // 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)

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

    除了对象的原型，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. });
    16. // 等同于
    17. var obj = Object.create({});
    18. obj.p1 = 123;
    19. obj.p2 = 'abc';

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

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

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

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

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

    上面代码中，o1和o2都是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 = {};
    4. obj.__proto__ = p;
    5. 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. };
    8. var proto = {
    9.   print: function () {
    10.     console.log(this.name);
    11.   }
    12. };
    14. A.__proto__ = proto;
    15. B.__proto__ = proto;
    17. A.print() // 张三
    18. B.print() // 李四
    20. A.print === B.print // true
    21. A.print === proto.print // true
    22. B.print === proto.print // true

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

    获取原型对象方法的比较

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

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

    上面代码首先新建了一个对象obj，它的__proto__属性，指向构造函数（Object或obj.constructor）的prototype属性。

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

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

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

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

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

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

    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 };
    3. var o2 = Object.create(o1, {
    4.   p2: { value: "abc", enumerable: true }
    5. });
    7. for (p in o2) {
    8.   console.info(p);
    9. }
    10. // p2
    11. // p1

    上面代码中，对象o2的p2属性是自身的，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. // ]

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

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

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

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

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

    参考链接

    • Dr. Axel Rauschmayer,