ES6对象的新增方法

一、Object.is()

• 目的：用来比较两个值是否严格相等
• 用法：与严格比较符(===)的行为基本一致，不同之处有2个：1)+0不等于-0；2)NaN等于自身

+0 === -0 //true
NaN === NaN // false

Object.is(+0, -0) // false
Object.is(NaN, NaN) // true

二、Object.assign()

• 目的： 用于将对象合并，将源对象可枚举的属性，复制到目标对象
• 用法：Object(target, source)第一个参数是目标对象，后面的参数都是源对象，若目标和源有同名属性，或多个源有同名属性，后面的属性会覆盖前面的属性，该方法只考虑对象自身属性，不考虑继承的属性

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}

• 注意：
  1.该方法实行的是浅拷贝

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

obj1.a.b = 2;
obj2.a.b // 2

2. 同名属性替换
3. 可用来处理数组
4. 取值函数的处理
   该方法要复制的值是一个取值函数，那么将求值后再复制

const source = {
  get foo() { return 1 }
};
const target = {};

Object.assign(target, source)
// { foo: 1 }

• 用途：

1. 为对象添加属性
2. 为对象添加方法
3. 克隆对象
4. 合并对象，可使用扩展运算符
5. 为属性指定默认值，但该值最好是简单类型，否则会发生覆盖

三、Object.getOwnPropertyDescriptors()

• 目的：用于获取指定对象所有自身属性(非继承属性)的描述对象，解决Object.assign()无法正确拷贝get和set属性的问题

const obj = {
  foo: 123,
  get bar() { return 'abc' }
};
Object.getOwnPropertyDescriptors(obj)
// { foo:
//    { value: 123,
//      writable: true,
//      enumerable: true,
//      configurable: true },
//   bar:
//    { get: [Function: get bar],
//      set: undefined,
//      enumerable: true,
//      configurable: true } }

• 对象拷贝：Object.getOwnPropertyDescriptors()方法配合Object.defineProperties()方法

const source = {
  set foo(value) {
    console.log(value);
  }
};
const target2 = {};
Object.defineProperties(target2, Object.getOwnPropertyDescriptors(source));
Object.getOwnPropertyDescriptor(target2, 'foo')
// { get: undefined,
//   set: [Function: set foo],
//   enumerable: true,
//   configurable: true }

四、关于原型对象的操作

1.Object.setPrototypeOf()

设置一个对象的原型

let proto = {};
let obj = { x: 10 };
Object.setPrototypeOf(obj, proto);

proto.y = 20;
proto.z = 40;

obj.x // 10
obj.y // 20
obj.z // 40

2.Object.getPrototypeOf()

读取一个对象的原型

Object.getPrototypeOf(obj);

五、关于对象键值的操作

1.Object.keys()

返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键名

var obj = { foo: 'bar', baz: 42 };
Object.keys(obj)
// ["foo", "baz"]

2.Object.values()

返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值

const obj = { foo: 'bar', baz: 42 };
Object.values(obj)
// ["bar", 42]

3.Object.entries()

返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值对数组

const obj = { foo: 'bar', baz: 42 };
Object.entries(obj)
// [ ["foo", "bar"], ["baz", 42] ]

4.Object.fromEntries()

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

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