1、Object.assign(target,source1,source2,...)

主要用于對象的合并，將源對象source的所有可枚舉屬性合并到目標對象target上

• 只拷貝源對象的自身屬性，不拷貝繼承(原型上)的屬性，同名屬性會替換。
• 實行的是淺拷貝，而不是深拷貝。也就是說，如果源對象某個屬性的值是對象，那么目標對象拷貝得到的是這個對象的引用。
• 進行值的復制，如果要復制的值是一個取值函數(shù)，那么將求值后再復制。
• 可以用來處理數(shù)組，但是會把數(shù)組視為對象

const target = {
    x : 0,
    y : 1
};
const source = {
    x : 1,
    z : 2 ,
    fn : {
        number : 1
    }
};
Object.assign(target, source);  
// target  {x : 1, y : 1, z : 2, fn : {number : 1}}    // 同名屬性會被覆蓋
// source  {x : 1, z : 2, fn : {number : 1}}
target.fn.number = 2;                                  // 拷貝為對象引用
// source  {x : 1, z : 2, fn : {number : 2}}
 
function Person(){
    this.name = 1
};
Person.prototype.country = 'china';
let student = new Person();
student.age = 29 ;
const young = {insterst : 'sport'};
Object.assign(young,student);
// young {instest : 'sport' , age : 29, name: 1}               // 只能拷貝自身的屬性，不能拷貝prototype
 
Object.assign([1, 2, 3], [4, 5])                      // 把數(shù)組當作對象來處理
// [4, 5, 3]

2、Object.create(proto[, propertiesObject])

該方法創(chuàng)建一個新對象，使用現(xiàn)有的對象來提供新創(chuàng)建的對象的proto

• proto：必須。新創(chuàng)建對象的原型對象，即通過 Object.create()生成的對象的原型 指向 proto(可以是 null、對象、函數(shù)的 prototype 屬性)，設置原型對象的屬性和方法。
  （注：創(chuàng)建空原型的對象時需傳 null , 否則會拋出 TypeError 異常）。
• propertiesObjec：可選。 添加到新創(chuàng)建對象的可枚舉屬性（即其自身的屬性，而不是原型鏈上的枚舉屬性）對象的屬性描述符以及相應的屬性名稱。這些屬性對應 Object.defineProperties()的第二個參數(shù)。
• 返回值：一個新對象，帶著指定的原型對象和屬性。

var parent = {
    x : 1,
    y : 1
}
var child = Object.create(parent,{
    z : {  
        writable:true,
        configurable:true,
        value: "newAdd"
    }
});
console.log(child)
console.log(Object.getPrototypeOf(child)) // {x: 1, y: 1}

image.png

new Object() 和 Object.create()比較

1、對象創(chuàng)建方式

• new Object(obj) ：通過構(gòu)造函數(shù)的對象, 對象添加的屬性 obj 是在自身實例下

const org = {
   type: 'human'
}
var Obj = new Object(org)
console.log(Obj) // { type: 'human' }
console.log(Obj.__proto__) // {} -> built-in
console.log(Obj.type) // human

• Object.create(proto[, propertiesObject]) ：創(chuàng)建的新對象繼承一個對象。 添加的屬性 proto 是在原型下，添加的屬性 propertiesObject 才在自身實例下

var ObjCre = Object.create(org, { name: { value: "JyLie" } })
console.log(ObjCre) // {name: 'JyLie'}
console.log(ObjCre.__proto__) // { type: 'human' }
console.log(ObjCre.type) // human

2、創(chuàng)建空對象時，是否有原型屬性

• Object.create(null)創(chuàng)建空對象，新對象是沒有原型屬性的

Object.create(null) // {} 沒有原型對象的空對象。純空對象。

• 構(gòu)造函數(shù)或?qū)ο笞置媪糠椒▌?chuàng)建空對象時，新對象有原型屬性（built-in）

new Object() // {} 擁有built-in

3、對象屬性描述符

• 通過 Object.create 第二個參數(shù)創(chuàng)建非空對象的屬性描述符默認是為 false 的，不可寫,不可枚舉,不可配置

3、Object.entries() 和 Object.fromEntries()

Object.entries()返回一個給定對象自身可枚舉屬性的鍵值對數(shù)組，其排列與使用 for…in 循環(huán)遍歷該對象時返回的順序一致（區(qū)別在于 for-in 循環(huán)還會枚舉原型鏈中的屬性）
Object.fromEntries() 方法把鍵值對列表轉(zhuǎn)換為一個對象。

const object1 = {
    a: 'somestring',
    b: 42,
    c: {
        d: true,
        e: 22
    }
};
let attr = Object.entries(object1)
console.log(attr);//[['a': 'somestring'],['b': 42],['c',{d: true, e: 22}]]
for (let [key, value] of attr) {
    console.log(`${key}: ${value}`);
    // a: somestring
    // b: 42
    // c: [object Object]
}
let obj = Object.fromEntries(attr) 
console.log(obj) // {a: "somestring", b: 42, c: {{d: true, e: 22}}}

4、Object.defineProperty()

會直接在一個對象上定義一個新屬性，或者修改一個對象的現(xiàn)有屬性并指定該屬性的配置，并返回此對象。
Object.defineProperty(obj, prop, descriptor)

• obj 要定義屬性的對象
• prop 要定義或修改的屬性的名稱或 Symbol
• descriptor 要定義或修改的屬性描述符,如果不設置屬性的特性，那么configurable、enumerable、writable這些值都為默認的false

• 屬性描述符

數(shù)據(jù)描述符和存取描述符不能同時是兩者,如果一個描述符同時擁有 value 或 writable 和 get 或 set 鍵，則會產(chǎn)生一個異常。（因為get和set設置的時候js會忽略value和writable的特性）

公用
configurable 默認為 false。
是否可以刪除目標屬性或是否可以再次修改屬性的特性（ writable, configurable, enumerable）。設置為true可以被刪除或可以重新設置特性；設置為false，不能被可以被刪除或不可以重新設置特性。

var o = {}; // 創(chuàng)建一個新對象
Object.defineProperty(o, 'a', {
    configurable:false,
    value:1
});
console.log(o.a); // 1
    delete o.a ;
    console.log(o.a); // 1

Object.defineProperty(o, 'b', {
    configurable:true,
    value:1
});
console.log(o.b); // 1
delete o.b ;
console.log(o.b); // undefined

enumerable 默認為 false
此屬性是否可以被枚舉（使用for...in或Object.keys()）。設置為true可以被枚舉；設置為false，不能被枚舉。默認為false。

var o = {}; 
Object.defineProperty(o, 'a', {
      value: 1,
      enumerable:true,
      configurable:true
 });
Object.defineProperty(o, 'b', {
      value: 2,
      enumerable:true
});
Object.defineProperty(o, 'c', {
      value: 3 
      //默認enumerable為false
});
o.d = 4; // 如果使用直接賦值的方式創(chuàng)建對象的屬性，則 enumerable 為 true
for (const key in o) {
      console.log('1',key); // a b d
 }

數(shù)據(jù)描述符
value 默認 undefined
該屬性對應的值。
writable 默認為 false
屬性的值value是否可以被重寫。設置為true可以被重寫；設置為false，不能被重寫。

var o = {}; // 創(chuàng)建一個新對象
// 在對象中添加一個屬性與數(shù)據(jù)描述符的示例
Object.defineProperty(o, 'a', {
  value : 30,
  writable : true,
  enumerable : true,
  configurable : true
});
console.log(o.a) // 30
Object.defineProperty(o, 'a', {
      value: 30,
      writable: false
});
o.a = 40;
console.log(o.a); // 30 無法修改

存取描述符
get 默認為 undefined
屬性的 getter 函數(shù)，如果沒有 getter，則為 undefined。當訪問該屬性時，會調(diào)用此函數(shù)。執(zhí)行時不傳入任何參數(shù)，但是會傳入 this 對象（由于繼承關(guān)系，這里的this并不一定是定義該屬性的對象）。該函數(shù)的返回值會被用作屬性的值。
set 默認為 undefined
屬性的 setter 函數(shù)，如果沒有 setter，則為 undefined。當屬性值被修改時，會調(diào)用此函數(shù)。該方法接受一個參數(shù)（也就是被賦予的新值），會傳入賦值時的 this 對象。

var o = {}; // 創(chuàng)建一個新對象
var value;
Object.defineProperty(o, "a", {
  enumerable: true,
  configurable: true,
  get() {
    return value
  },
  set(newvalue) {
    console.log('newvalue',newvalue)
    value = newvalue;
  }
});
console.log(o.a) // undefined
o.a=1; // 觸發(fā)set特性 打印 newvalue 1
console.log(o.a) // 1

5、Object.defineProperties()

給對象添加多個屬性并分別指定它們的配置。
Object.defineProperties(obj, props)

• obj
  在其上定義或修改屬性的對象。
• props
  要定義其可枚舉屬性或修改的屬性描述符的對象。

var obj = {};
Object.defineProperties(obj, {
  'property1': {
    value: 30,
    writable: true
  },
  'property2': {
    value: 'xxx',
    writable: false
  }
});

6、Object.keys() 和 Object.values()

Object.keys()：返回一個由給定對象的自身可枚舉屬性組成的數(shù)組，不包括原型鏈上的可枚舉屬性
Object.values()：返回一個由給定對象的自身可枚舉屬性值組成的數(shù)組，不包括原型鏈上的可枚舉屬性值
for...in 循環(huán)是 遍歷對象的每一個可枚舉屬性,包括原型鏈上面的可枚舉屬性,

const object1 = {
    a: 'somestring',
    b: 42
};
console.log(Object.keys(object1)) // ["a", "b"]
console.log(Object.values(object1)) // ["somestring", 42]

7、Object.getOwnPropertyNames(obj)

返回一個數(shù)組，包含對象自身的所有屬性（不含 Symbol 屬性，不包括原型鏈上面的，但是包括不可枚舉屬性）的鍵名

8、Object.getOwnPropertySymbols(obj)

返回一個數(shù)組，包含對象自身的所有 Symbol 屬性的鍵名

9、Reflect.ownKeys(obj)

返回一個數(shù)組，包含對象自身的所有鍵名，不管鍵名是 Symbol 或字符串，也不管是否可枚舉