js内置对象

Js 标准内置对象

Object

Object 是 JavaScript 的一种数据类型。它用于存储各种键值集合和更复杂的实体。可以通过 Object() 构造函数或者使用对象字面量的方式创建对象。

Object.assign()

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

const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };

const returnedTarget = Object.assign(target, source); 
// target 目标对象 需要应用源对象属性的目标对象，修改后将作为返回值
// source 源对象

console.log(target);
// Expected output: Object { a: 1, b: 4, c: 5 }

描述

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

Object.assign() 方法只会拷贝源对象可枚举的的自有属性到目标对象。该方法在源对象上使用 [[Get]]，在目标对象上使用 [[Set]]，因此它会调用 getter 和 setter。故它对属性进行赋值，而不仅仅是复制或定义新的属性。如果合并源对象包含 getter 的新属性到原型中，则可能不适合使用此方法。

如果要将属性定义（包括它们的可枚举性）复制到原型中，则应改用 Object.getOwnPropertyDescriptor() 和 Object.defineProperty() 方法。

字符串和 Symbol 类型属性都会被复制。

如果赋值期间出错，例如如果属性不可写，则会抛出 TypeError；如果在抛出异常之前已经添加了一些属性，则这些属性会被保留，而 target 对象也会被修改。

备注： Object.assign() 不会在源对象值为 null 或 undefined 时抛出错误

1. 复制对象

const obj = { a: 1 };
const copy = Object.assign({}, obj);
console.log(copy); // { a: 1 }

2. 深拷贝问题

   针对深拷贝，需要使用其他办法，因为 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 } }
   
   

   3. 合并对象

   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 }
   
   

   属性会被后续参数中具有相同属性的其他对象覆盖。

   4. 拷贝 Symbol 类型属性

   const o1 = { a: 1 };
   const o2 = { [Symbol("foo")]: 2 };
   
   const obj = Object.assign({}, o1, o2);
   console.log(obj); // { a : 1, [Symbol("foo")]: 2 } (cf. bug 1207182 on Firefox)
   Object.getOwnPropertySymbols(obj); // [Symbol(foo)]
   
   

   5. 原型链上的属性和不可枚举的属性不能被复制

   6. 基本类型会被封装为对象

   const v1 = "abc";
   const v2 = true;
   const v3 = 10;
   const v4 = Symbol("foo");
   
   const obj = Object.assign({}, v1, null, v2, undefined, v3, v4);
   // 基本类型将被封装，null 和 undefined 将被忽略。
   // 注意，只有字符串封装对象才拥有可枚举的自有属性。
   console.log(obj); // { "0": "a", "1": "b", "2": "c" }
   
   

   7. 异常会中断后续的复制