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

如果目標物件和源物件有同名屬性，後面的屬性會覆蓋前面的屬性

      const target = { a: 1 }
      const source1 
 
= { b: 2, a: 100 }
      const source2 = { c: 3, b: 200 }
      const result = Object.assign(target, source1, source2)
      console.log(target) // {a: 100, b: 200, c: 3}
      console.log(result) // {a: 100, b: 200, c: 3}

以上兩點特徵使用物件的【解構賦值】效果一樣

      const target = { a: 1 }
      const source1 = { b: 2, a: 100 }
      const source2 
 
= { c: 3, b: 200 }
      const result = Object.assign(target, source1, source2)
      const result1 = { ...target, ...source1, ...source2 }
      console.log(target) // {a: 100, b: 200, c: 3}
      console.log(result) // {a: 100, b: 200, c: 3}
      console.log(result1) // {a: 100, b: 200, c: 3}

Object.assign()如果只有一個引數，會直接返回這個引數

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

如果該引數不是物件，則會先轉成物件，然後返回

      console.log(Object.prototype.toString.call(Object.assign(2))) // [object Number]
      console.log(Object.prototype.toString.call(Object.assign(NaN))) // [object Number]
      console.log(Object.prototype.toString.call(Object.assign(true))) // [object Boolean]
      console.log(Object.prototype.toString.call(Object.assign('abc'))) // [object String]
      console.log(Object.prototype.toString.call(Object.assign(new Date()))) // [object Date]

undefined和null無法轉成物件，如果用它們作為引數，就會報錯

      console.log(Object.prototype.toString.call(Object.assign(undefined))) // Uncaught TypeError: Cannot convert undefined or null to object
      console.log(Object.prototype.toString.call(Object.assign(null))) // Uncaught TypeError: Cannot convert undefined or null to object

      const obj = { a: 1 }
      console.log(Object.assign(obj) === obj) // true
      console.log(Object.assign(obj, undefined) === obj) // true
      console.log(Object.assign(obj, null) === obj) // true

其他資料型別的值，不在首位（target）也不會報錯，但是，除了字串會以陣列形式，拷貝入目標物件，其他值都不會產生效果

      const s1 = 'abc'
      const s2 = true
      const s3 = 100
      const s4 = NaN
      const s5 = new Date()
      const obj = {}
      Object.assign(obj, s1, s2, s3, s4, s5)
      console.log(obj) // {0: 'a', 1: 'b', 2: 'c'}

因為只有字串的包裝物件，會產生可列舉屬性

使用Object()將字串、數字、布林值、NaN、Date轉成對應的包裝物件，可以看到它們的原始值都在包裝物件的內部屬性 [[PrimitiveValue]] 上面，這個屬性是不會被Object.assign()拷貝的。只有字串的包裝物件，會產生可列舉的實義屬性，這些屬性才可以被拷貝

原型鏈上的屬性不會被Object.assign()拷貝

      Object.prototype.age = 100
      const target = {}
      const source = { name: '小明' }
      Object.assign(target, source)
      console.log(target) // {name: '小明'}

不可列舉屬性不會被Object.assign()拷貝

      const target = {}
      const source = { name: '小明' }
      Object.defineProperty(source, 'latent', {
        value: '我是一個隱藏的屬性',
        enumerable: false // 預設為false，不可列舉
      })
      Object.assign(target, source)
      console.log(target) // { name: '小明' }

屬性名為Symbol值的屬性，會被Object.assign()拷貝

      const target = {}
      const source = { name: '小明' }
      Object.defineProperty(source, 'latent', {
        value: '我是一個隱藏的屬性',
        enumerable: true
      })
      Object.assign(target, source, { [Symbol('xx')]: 'xx' })
      console.log(target) // {name: '小明', latent: '我是一個隱藏的屬性', Symbol(xx): 'xx'}

Object.assign(null)