Object.getPrototypeOf()

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

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

特殊对象原型

  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.create()

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
  15. //如果想要生成一个不继承任何属性（比如没有toString和valueOf方法）的对象，可以将Object.create的参数设为null
  16. var obj = Object.create(null);
  17. obj.valueOf()
  18. // TypeError: Object [object Object] has no method 'valueOf'
  20. //Object.create方法生成的新对象，动态继承了原型。在原型上添加或修改任何方法，会立刻反映在新对象之上
  21. var obj1 = { p: 1 };
  22. var obj2 = Object.create(obj1);
  23. obj1.p = 2;
  24. obj2.p // 2
  26. //Object.create方法还可以接受第二个参数。该参数是一个属性描述对象，它所描述的对象属性，会添加到实例对象，作为该对象自身的属性
  27. var obj = Object.create({}, {
  28.   p1: {
  29.     value: 123,
  30.     enumerable: true,
  31.     configurable: true,
  32.     writable: true,
  33.   },
  34.   p2: {
  35.     value: 'abc',
  36.     enumerable: true,
  37.     configurable: true,
  38.     writable: true,
  39.   }
  40. });
  42. // 等同于
  43. var obj = Object.create({});
  44. obj.p1 = 123;
  45. obj.p2 = 'abc';
  49. //Object.create方法生成的对象，继承了它的原型对象的构造函数
  50. function A() {}
  51. var a = new A();
  52. var b = Object.create(a);
  54. b.constructor === A // true
  55. b instanceof A // true

Object.prototype.isPrototypeOf()

实例对象的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

Object.prototype.proto

实例对象的proto属性（前后各两个下划线），返回该对象的原型。该属性可读写

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

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

获取原型对象方法的比较

  • obj.proto
  • obj.constructor.prototype
  • Object.getPrototypeOf(obj) (推荐)

Object.getOwnPropertyNames()

Object.getOwnPropertyNames方法返回一个数组，成员是参数对象本身的所有属性的键名，不包含继承的属性键名
Object.getOwnPropertyNames(Date) // ["parse", "arguments", "UTC", "caller", "name", "prototype", "now", "length"]

Object.prototype.hasOwnProperty()

对象实例的hasOwnProperty方法返回一个布尔值，用于判断某个属性定义在对象自身，还是定义在原型链上
hasOwnProperty方法是 JavaScript 之中唯一一个处理对象属性时，不会遍历原型链的方法

in 运算符和 for…in 循环

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

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

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

对象的拷贝

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

  • 确保拷贝后的对象，与原对象具有同样的原型。
  • 确保拷贝后的对象，与原对象具有同样的实例属性。
  1. function copyObject(orig) {
  2.   return Object.create(
  3.     Object.getPrototypeOf(orig),
  4.     Object.getOwnPropertyDescriptors(orig)
  5.   );
  6. }

深拷贝 浅拷贝

JSON.parse(JSON.stringify(a))：只能处理正确的JSON数据，函数等无法处理
lodash
自定义函数

  1. var _ = require('lodash')
  2. var a = {
  3.     name: 'xm',
  4.     age: 11,
  5.     sex: 'female',
  6.     card: ['visa', 'zs'],
  7. }
  9. var b = {}
  11. var clone1 = JSON.parse(JSON.stringify(a)) //深拷贝
  12. var clone2 = Object.assign({}, a) //浅拷贝
  13. var clone3 = {...a } //浅拷贝
  14. var clone4 = _.cloneDeep(a) //深拷贝
  15. a.card.push('jh')
  17. console.log(clone1)//{name: 'xm', age: 11, sex: 'female', card: Array(2)}
  18. console.log(clone2)//{name: 'xm', age: 11, sex: 'female', card: Array(3)}
  19. console.log(clone3)//{name: 'xm', age: 11, sex: 'female', card: Array(3)}
  20. console.log(clone4)//{name: 'xm', age: 11, sex: 'female', card: Array(2)}
  1. function clone(obj) {
  2.     var copy
  4.     // Handle the 3 simple types, and null or undefined
  5.     if (null == obj || 'object' != typeof obj) return obj
  7.     // Handle Date
  8.     if (obj instanceof Date) {
  9.         copy = new Date()
  10.         copy.setTime(obj.getTime())
  11.         return copy
  12.     }
  14.     // Handle Array
  15.     if (obj instanceof Array) {
  16.         copy = []
  17.         for (var i = 0, len = obj.length; i < len; i++) {
  18.             copy[i] = clone(obj[i])
  19.         }
  20.         return copy
  21.     }
  23.     // Handle Object
  24.     if (obj instanceof Object) {
  25.         copy = {}
  26.         for (var attr in obj) {
  27.             if (obj.hasOwnProperty(attr)) copy[attr] = clone(obj[attr])
  28.         }
  29.         return copy
  30.     }
  32.     throw new Error("Unable to copy obj! Its type isn't supported.")
  33. }