对象新增方法

对象的新增方法

注意：

• null 和 undefined 不能转换成对象,否则会报错
• 数字转换成对象 Number(1) 不可枚举
• 字符串转换成对象 String('str') 可枚举
• 布尔值转换为对象 Boolean(true)、Boolean(false) 不可枚举

参考资料 : 阮一峰 ECMAScript 6 入门

1.Object.is(值1，值2)

• 用来比较两个值是否严格相等，和 全等运算符 === 类似，但也有不同之处

• console.log(-0 == +0);//true
  console.log(-0 === +0);//true
  console.log(NaN == NaN);//false
  console.log(NaN === NaN);//false
  console.log({ a: 1 } == { a: 1 });//false,地址指向不一样,是独立的两个对象
  console.log({} == {});//false
  console.log({} === {});//fals  
  
  /* ES6 提出“Same-value equality”（同值相等）算法，用来解决这个问题。Object.is就是部署这个算法方法。
  它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致。 */
  console.log(Object.is('foo', 'foo'));//true
  console.log(Object.is({}, {}));//false
  
  // 和 === 的不同点
  console.log(Object.is(+0, -0));//false
  console.log(Object.is(NaN, NaN));//true
  

2.Object.assign(target,source) target目标对象，source源对象

• 用于对象合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）。
• 注意点：
  • 如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。

  const target = { a: 1, b: 1 };
  const source1 = { b: 2, c: 2 };
  const source2 = { c: 3 };
  Object.assign(target, source1, source2);
  target // {a:1, b:2, c:3}
  

  • 不可枚举属性不会拷贝进去,比如Number()、Boolean()不会被拷贝进去
  • Object.assign() 方法实行的是浅拷贝

  const obj1 = {a: {b: 1}};
  const obj2 = Object.assign({}, obj1);
  obj1.a.b = 2;
  obj2.a.b // 2
  

  • 同名属性替换

  const target = { a: { b: 'c', d: 'e' } }
  const source = { a: { b: 'hello' } }
  Object.assign(target, source)
  // { a: { b: 'hello' } }
  

  • 数组的处理

  Object.assign([1, 2, 3], [4, 5])
  // [4, 5, 3]
  

3.__proto__属性，Object.setPrototypeOf()，Object.getPrototypeOf()

• Object.setPrototypeOf方法的作用与__proto__相同，用来设置一个对象的原型对象（prototype），返回参数对象本身。
  • 格式Object.setPrototypeOf(object, prototype)
  • Object.setPrototypeOf(object, prototype)=== object
• Object.getPrototypeOf() 方法与Object.setPrototypeOf方法配套，用于读取一个对象的原型对象。

  function Rectangle() {
    // ...
  }
  
  const rec = new Rectangle();
  
  Object.getPrototypeOf(rec) === Rectangle.  prototype
  // true
  
  Object.setPrototypeOf(rec, Object.prototype);
  Object.getPrototypeOf(rec) === Rectangle.  prototype
  // false
  

4.Object.keys()，Object.values()，Object.entries()

• 对象转换成数组
• 三者都会返回一个数组，成员是参数对象自身(不含继承的)所有可遍历属性的对应值
• 如果原对象的属性名是一个 Symbol 值，该属性会被忽略。

  const obj = Object.create({}, {p: {value: 42}});
  Object.values(obj) // []
  

  • 上面代码中，Object.create方法的第二个参数添加的对象属性（属性p），如果不显式声明，默认是不可遍历的，因为p的属性描述对象的enumerable默认是false，Object.values不会返回这个属性。只要把enumerable改成true，Object.values就会返回属性p的值。
• Object.values会过滤属性名为 Symbol 值的属性。

  Object.values({ [Symbol()]: 123, foo: 'abc' });
  // ['abc']
  

• 如果Object.values方法的参数是一个字符串，会返回各个字符组成的一个数组。

  Object.values('foo')
  // ['f', 'o', 'o']
  

• 如果参数不是对象，Object.values会先将其转为对象。由于数值和布尔值的包装对象，都不会为实例添加非继承的属性。所以，Object.values会返回空数组。

  Object.values(42) // []
  Object.values(true) // []
  

5.Object.fromEntries()

• Object.fromEntries()方法是Object.entries()的逆操作，用于将一个键值对数组转为对象。

  Object.fromEntries([
  ['foo', 'bar'],
  ['baz', 42]
  ])
  // { foo: "bar", baz: 42 }
  

6.Object.hasOwn(obj，属性名)

• 作用和hasOwnProperty()方法类似,可以判断某个属性是否为原生属性。

function MyClass() { }
        MyClass.prototype.age = 18//我是原型上的18
        let mc = new MyClass()
        mc.name = 'Kangf'
        console.log(mc.age);//18
        console.log('age' in mc);//true
        console.log('name' in mc);//true
        console.log(mc.hasOwnProperty('name'));//true
        console.log(mc.hasOwnProperty('age'));//false

        console.log('分界线-----------');

        const foo = Object.create({ a: 123 })
        foo.b = 456
        console.log(foo);
        console.log(foo.hasOwnProperty('a'));//false
        console.log(foo.hasOwnProperty('b'));//true
        console.log(foo.hasOwnProperty('c'));//false

        console.log('分界线-----------');

        console.log(Object.hasOwn(foo, 'a'));//false
        console.log(Object.hasOwn(foo, 'b'));//true
        console.log(Object.hasOwn(foo, 'c'));//false

• Object.hasOwn()的一个好处是，对于不继承Object.prototype的对象不会报错，而hasOwnProperty()是会报错的。

        // ！！！！！！下面示例中，Object.create(null)返回的对象obj是没有原型的，不继承任何属性，这导致调用obj.hasOwnProperty()会报错，但是Object.hasOwn()就能正确处理这种情况。！！！！！！！！
        const obj = Object.create(null)
        console.log(Object.hasOwn(obj, 'foo'));//不报错，返回false
        console.log(obj.hasOwnProperty('foo'));//报错