213：对象

判断两者是否相等：

  1. console.log(true === 1); // false 
  2. console.log({} === {}); // false 
  3. console.log("2" === 2); // false
  4. console.log(NaN === NaN); // false 
  5. console.log(isNaN(NaN)); // true
  7. console.log(Object.is(true, 1)); // false 
  8. console.log(Object.is({}, {})); // false 
  9. console.log(Object.is("2", 2)); // false
  10. // 正确的 NaN 相等判定
  11. console.log(Object.is(NaN, NaN)); // true
  13. // 2. 属性值简写,可计算属性
  14. let name = 'Matt'; 
  15. const nameKey = 'age';
  16. let person = { 
  17.  // name: name 
  18.   name,
  19.   [nameKey]: '12', // [方括号内部的nameKye会计算为'age',此处也可以是根据函数或者方法设置]
  20. };

对象解构

  1. // 嵌套解构时，使用的是浅拷贝，修改第一层的属性，原值不会改变，更深层会改变
  2. let person = { 
  3.  name: 'Matt', 
  4.  age: 27, 
  5.  job: { 
  6.  title: 'Software engineer' 
  7.  } 
  8. }; 
  9. // 声明 title 变量并将 person.job.title 的值赋给它
  10. let { job: job ,age: myage } = person; 
  11. job.title = 'hello'
  12. myage = 12
  13. console.log(title,myage); // hello 12
  14. console.log(person.job.title,person.age) // hello 27
  16. // 可以采用嵌套的方式，深度拷贝，修改对应的属性时，原值不会改变
  17. // 声明 title 变量并将 person.job.title 的值赋给它
  18. let { job: { title } } = person; // 这样改变title时，原值不会该改变
  19. title = '123'
  20. console.log(title, person.job.title); // 123 'hello'

230：hasOwnProperty()能够清楚地看到访问的是实例属性还是原型属性

  1. console.log(person1.name); // "Greg"，来自实例  
  2. console.log(person1.hasOwnProperty("name")); // true   通过hasOwnProperty,属性来自实例上返回true，来自原型上返回false
  3. console.log(person2.name); // "Nicholas"，来自原型
  4. console.log(person2.hasOwnProperty("name")); // false
  5. console.log("name" in person1) // true  通过in,无论该属性是在实例上还是在原型上都返回true
  6. // 确定某个属性是否存在于原型上
  7. function hasPrototypeProperty(object, name){ 
  8.  return !object.hasOwnProperty(name) && (name in object); 
  9. }
  10. // 对象上所有可枚举的实例属性，可以使用 Object.keys()方法
  11. let keys = Object.keys(Person.prototype); 
  12. console.log(keys); // "name,age,job,sayName"
  13. let p1 = new Person(); 
  14. p1.name = "Rob"; 
  15. p1.age = 31; 
  16. let p1keys = Object.keys(p1); // 只列举出实例上的key
  17. console.log(p1keys); // "[name,age]"
  18. // 列出所有实例属性，无论是否可以枚举，都可以使用 Object.getOwnPropertyNames()
  19. let keys = Object.getOwnPropertyNames(Person.prototype); 
  20. console.log(keys); // "[constructor,name,age,job,sayName]"
  21. // for-in 循环和 Object.keys()的枚举顺序是不确定的，Object.getOwnPropertyNames()、Object.getOwnPropertySymbols()和 Object.assign()的枚举顺序是确定性的。
  23. // Object.values()返回对象值的数组，Object.entries()返回键/值对的数组,[sym]: 'foo'这种符号属性会被忽略
  24. const o = { 
  25.  foo: 'bar', 
  26.  baz: 1, 
  27.  qux: {} 
  28. }; 
  29. console.log(Object.values(o)); 
  30. // ["bar", 1, {}] 
  31. console.log(Object.entries((o))); 
  32. // [["foo", "bar"], ["baz", 1], ["qux", {}]]