摘要：掛在函數上的方法，稱之為靜態方法。方法返回一個由指定對象的所有自身屬性的屬性名包括不可枚舉屬性組成的數組。以上常用的方法合并或復制對象使用遍歷對象使用創建對象使用以上如有偏差歡迎指正學習，謝謝。

內置提供了一個對象為 Object ，也被稱之為是構造函數，用來創建對象用的。在 javascript 函數也是對象，是一種可被執行的對象，所以稱Object為對象也是可以的。掛在函數上的方法，稱之為靜態方法。

如果對這個方法不了解，必須先看，下面的某些方法要定義不可枚舉的屬性時會用到。

移步閱讀：https://segmentfault.com/a/1190000007434923

方法返回指定對象上一個自有屬性對應的屬性描述符。（自有屬性指的是直接賦予該對象的屬性，不需要從原型鏈上進行查找的屬性）

屬性描述符是一個對象，記錄了此屬性，是否可被枚舉、是否可被刪除、是否可被改寫、屬性的值。

let obj = {a:1,b:2};

console.log(Object.getOwnPropertyDescriptor(obj,"a"));

返回值是一個對象：

{
    configurable: true
    enumerable: true
    value: 1
    writable: true
}

一般對象定義的屬性，不使用 Object.defineProperty() 定義的，都是可被枚舉、可被刪除、可被改寫。

方法返回一個由指定對象的所有自身屬性的屬性名（包括不可枚舉屬性）組成的數組。

let obj = {
    a:1,
    b:2
}
console.log(Object.getOwnPropertyNames(obj)); //["a","b"]


Object.defineProperty(obj,"c",{
    enumerable: false
})

console.log(Object.getOwnPropertyNames(obj)); //["a","b","c"]

這個方法被經常用到，作用是將一個或多個對象可枚舉的屬性合并到目標對象上，返回為目標對象。

用法：

let target = {a:1};

let t = Object.assign(target,{b:1},{c:1})

console.log(target); // {a:1,b:1,c:1}
console.log(t); // {a:1,b:1,c:1}
console.log(target === t); // true

通過以上測試會發現，將多個對象的屬性都合并到了對象 target 上，并且返回的依然是對象 target。
要注意，這種方式為淺拷貝（淺復制），遇到值為對象類型時，會引用相同的對象。

let target = {a:1};
let source = {b:1,users:["seven"]

Object.assign(target,source)

target.users.push("job"); 

console.log(target.users); // ["seven","job"]
console.log(source.users); // ["seven","job"]

以上的屬性 users 對應的值為數組，數組是引用類型的值，并沒有復制一份給到 target，所以對象 target 和 source 使用的是同一個對象。改變后會互相影響，如果要完全的脫離關系，可以選擇深復制，利用 jQuery 的 extend 函數。

此函數常用的應用場景是覆蓋函數定義的對象默認值，例如要封裝一個 Ajax ,要傳遞很多個參數，某些參數是可選的，采用傳遞一個對象的方式更利于擴展：

function Ajax(options){
    let defautls = {
        method:"get",
        data:{},
        success(){},
        error(){}
    }
    Object.assign(defautls,options)
}
Ajax({
    method:"post"
})

對象屬性是可選的，預先定義好默認值，當調用函數傳遞的屬性覆蓋掉默認設置的屬性。

此方法用基于傳入的參數對象作為原型來創建一個新對象。只能接受對象或者null作為參數。查看新對象的 proto 的值，為傳入的參數對象。

let obj = {
    a:1,
    b:2
}
let newObject = Object.create(obj);

console.log(newObject.__proto__ === obj); // true

以上就是把 obj 對象作為新創建對象的原型。

也可以傳入 null，意思是創建一個沒有任何原型的對象，這樣創建對象的方式更加高效。

應用場景為原型繼承上，例如一個函數的原型需要繼承另一個原型，就可以就可以基于一個原型對象創建一個新的對象，把新的對象賦值給另一個原型即可。

// 父類
function Person(){}
Person.prototype.say = function(){}

子類
function Coder(){}
// 需要繼承父類Peroson原型對象
Coder.prototype = Object.create(Person.prototype.)

判斷值是否相同，連一個奇葩的自身和自身不相等的 NaN 都可以判斷為相同。

console.log(Object.is(1,1)); // true
console.log(Object.is(NaN,NaN)); //true

返回指定對象的原型對象，（內部[[Prototype]]屬性的值）。[[Prototype]] 為內部使用的，我們一般使用 proto 這個瀏覽器提供的屬性來獲取對象的原型，但在 ES5 規范中 proto 并不是標準的屬性，是瀏覽器為了方便開發者查看對象的原型提供的，因為這個屬性使用起來方便，現在大多數瀏覽器都提供。如果要用規范方法獲取原型對象，建議使用 Object.getPrototypeOf

console.log(Object.getPrototypeOf({}) === Object.prototype); // true

let obj = {a:1};
let newObj = Object.create(obj); // 基于obj為原型創建新的對象

console.log(Object.getPrototypeOf(newObj) === obj); // true
console.log(newObj.__proto__ === Object.getPrototypeOf(newObj)); // true

這個方法設置一個指定的對象的原型 ( 即, 內部[[Prototype]]屬性）到另一個對象或 null。

let obj = {
    a:1,
    b:2
}

console.log(Object.getPrototypeOf(obj) === Object.prototype)

let newProto = {
    c:1
}

Object.setPrototypeOf(obj,newProto); // 把obj對象的原型設置為對象newProto

console.log(Object.getPrototypeOf(obj) === newProto); // true

方法會返回一個由一個給定對象的自身可枚舉屬性組成的數組，數組中屬性名的排列順序和使用 for...in 循環遍歷該對象時返回的順序一致 。

要注意，Object.keys 方法不能遍歷出不可枚舉的屬性,要遍歷出不可枚舉屬性，可使用 Object.getOwnPropertyNames。

let obj = {
    a:1,
    b:2
}
Object.defineProperty(obj,"c",{
    enumerable: false
})

console.log(Object.keys(obj)); //["a","b"]

返回一個給定對象自身的所有可枚舉屬性值的數組。與使用 for...in 循環順序保持一致，但 Object.values 不遍歷原型鏈。
把對象的 value 值存放在一個數組中。

let obj = {
    a:1,
    b:2
}
console.log(Object.values(obj)); //[1,2]

返回一個給定對象自身可枚舉屬性的鍵值對數組,與使用 for...in 循環順序保持一致，但 Object.entries 不遍歷原型鏈。

let obj = {a:1,b:2};
let keyValueArr = Object.entries(obj);
console.log(keyValueArr); // 打?。篬["a", 1],["b", 2]]

把對象的 key 和 value 存放在同一個數組中，第一項為 key ，第二項為 value 。

這個方法常常配合 for...of 語法使用來遍歷對象，

let obj = {a:1,b:2};
for(let [key,value] of Object.entries(obj)){
    console.log(key,value); // "a",1;"b",2
}

[key,value] 形式為解構賦值，右側 Object.entries(obj) 返回的是一個二維數組 [["a", 1],["b", 2]],這樣每次拿到數組中的一項 ["a",1],利用解構賦值的形式，將數組第一項賦值給 key，第二項賦值給 value。

以上常用的方法：

合并或復制對象使用Object.assgin;

遍歷對象使用 Object.keys

創建對象使用 Object.create

以上如有偏差歡迎指正學習，謝謝。