Javascript 一些常用的Object静态方法，点赞加关注持续更新~

Object静态方法

Object.is()

Object.is() 判断两个值是否为相同值，不等价于“===”

语法：

Object.is(value1, value2)

参数：

• value1

  要比较的第一个值。

• value2

  要比较的第二个值。

返回值：

返回一个布尔值，相同为true，不相同为false

描述：

Object.is() 确定两个值是否为相同值，如果以下其中一项成立，则两个值相同：

• 都是 undefined
• 都是 null
• 都是 true 或者都是 false
• 都是长度相同、字符相同、顺序相同的字符串
• 都是相同的对象（意味着两个值都引用了内存中的同一对象）
• 都是BigInt 且具有相同的数值
• 都是 symbol 且引用相同的 symbol 值
• 都是数字且
  • 都是 +0
  • 都是 -0
  • 都是 NaN
  • 都有相同的值，非零且都不是 NaN

示例：

// 案例 1：评估结果和使用 === 相同
Object.is(25, 25); // true
Object.is("foo", "foo"); // true
Object.is("foo", "bar"); // false
Object.is(null, null); // true
Object.is(undefined, undefined); // true
Object.is(window, window); // true
Object.is([], []); // false
const foo = { a: 1 };
const bar = { a: 1 };
const sameFoo = foo;
Object.is(foo, foo); // true
Object.is(foo, bar); // false
Object.is(foo, sameFoo); // true

// 案例 2: 带符号的 0
Object.is(0, -0); // false
Object.is(+0, -0); // false
Object.is(-0, -0); // true

// 案例 3: NaN
Object.is(NaN, 0 / 0); // true
Object.is(NaN, Number.NaN); // true

Object.keys()

Object.keys() 静态方法返回一个由给定对象自身的可枚举的字符串键属性名组成的数组。

如果你需要属性的值，请使用 Object.values()，如果你同时需要属性的键和值，请使用 Object.entries()

语法：

Object.keys(obj)

参数：

obj一个对象

返回值：

一个由给定对象自身可枚举的字符串键属性键组成的数组。

示例：

// 简单数组
const arr = ["a", "b", "c"];
console.log(Object.keys(arr)); // ['0', '1', '2']

// 类数组对象
const obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.keys(obj)); // ['0', '1', '2']

// 键的顺序随机的类数组对象
const anObj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.keys(anObj)); // ['2', '7', '100']

Object.values()

语法：

Object.values(obj)

参数：

obj一个对象

返回值：

一个包含了给定对象的自有可枚举字符串键属性值的数组

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

// 类数组对象
const arrayLikeObj1 = { 0: "a", 1: "b", 2: "c" };
console.log(Object.values(arrayLikeObj1)); // ['a', 'b', 'c']

// 具有随机键排序的类数组对象
// 使用数字键时，将按键的数字顺序返回值
const arrayLikeObj2 = { 100: "a", 2: "b", 7: "c" };
console.log(Object.values(arrayLikeObj2)); // ['b', 'c', 'a']

Object.entries()

Object.entries() 静态方法返回一个数组，包含给定对象自有的可枚举字符串键属性的键值对。

语法：

Object.entries(obj)

参数：

obj一个对象

返回值：

一个由给定对象自有的可枚举字符串键属性的键值对组成的数组。每个键值对都是一个包含两个元素的数组：第一个元素是属性的键（始终是字符串），第二个元素是属性值。

示例：

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

// 类数组对象
const obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]

// 具有随机键排序的类数组对象
const anObj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.entries(anObj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]

Object.assign()

Object.assign() 静态方法将一个或者多个源对象中所有可枚举的自有属性复制到目标对象，并返回修改后的目标对象。

语法：

Object.assign(target, ...sources)

参数：

• target

  需要应用源对象属性的目标对象，修改后将作为返回值。

• sources

  一个或多个包含要应用的属性的源对象。

返回值：

修改后的目标对象。

描述:

如果目标对象与源对象具有相同的[键（属性名），则目标对象中的属性将被源对象中的属性覆盖，后面的源对象的属性将类似地覆盖前面的源对象的同名属性。

深拷贝问题:

• 针对深拷贝，需要使用其他办法，因为 Object.assign() 只复制属性值
• 假如源对象是一个对象的引用，它仅仅会复制其引用值（引用地址）
• Object.assign()只能用作浅拷贝
• 深拷贝浅拷贝问题可见下面这篇博客：关于深拷贝和浅拷贝

示例：

浅拷贝

// 浅拷贝
const obj1 = { a: 0, b: { c: 0 } };
const obj2 = Object.assign({}, obj1);
console.log(obj2); // { a: 0, b: { c: 0 } }

obj1.a = 1;
console.log(obj1); // { a: 1, b: { c: 0 } }
console.log(obj2); // { a: 0, b: { c: 0 } }

obj2.a = 2;
console.log(obj1); // { a: 1, b: { c: 0 } }
console.log(obj2); // { a: 2, b: { c: 0 } }

obj2.b.c = 3;
console.log(obj1); // { a: 1, b: { c: 3 } }
console.log(obj2); // { a: 2, b: { c: 3 } }

// 深拷贝
const obj3 = { a: 0, b: { c: 0 } };
const obj4 = JSON.parse(JSON.stringify(obj3));
obj3.a = 4;
obj3.b.c = 4;
console.log(obj4); // { a: 0, b: { c: 0 } }

合并对象

const o1 = { a: 1 };
const o2 = { b: 2 };
const o3 = { c: 3 };

const obj = Object.assign(o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }
console.log(o1); // { a: 1, b: 2, c: 3 }，目标对象本身发生了变化

合并具有相同属性的对象

const o1 = { a: 1, b: 1, c: 1 };
const o2 = { b: 2, c: 2 };
const o3 = { c: 3 };

const obj = Object.assign({}, o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }