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

內置提供了一個對象為 Object ，也被稱之為是構造函數(shù)，用來創(chuàng)建對象用的。在 javascript 函數(shù)也是對象，是一種可被執(zhí)行的對象，所以稱Object為對象也是可以的。掛在函數(shù)上的方法，稱之為靜態(tài)方法。

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

移步閱讀：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() 定義的，都是可被枚舉、可被刪除、可被改寫。

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

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

通過以上測試會發(fā)現(xiàn)，將多個對象的屬性都合并到了對象 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 對應的值為數(shù)組，數(shù)組是引用類型的值，并沒有復制一份給到 target，所以對象 target 和 source 使用的是同一個對象。改變后會互相影響，如果要完全的脫離關系，可以選擇深復制，利用 jQuery 的 extend 函數(shù)。

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

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

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

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

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

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

以上就是把 obj 對象作為新創(chuàng)建對象的原型。

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

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

// 父類
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 規(guī)范中 proto 并不是標準的屬性，是瀏覽器為了方便開發(fā)者查看對象的原型提供的，因為這個屬性使用起來方便，現(xiàn)在大多數(shù)瀏覽器都提供。如果要用規(guī)范方法獲取原型對象，建議使用 Object.getPrototypeOf

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

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

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

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

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

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

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

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

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

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

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

把對象的 key 和 value 存放在同一個數(shù)組中，第一項為 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) 返回的是一個二維數(shù)組 [["a", 1],["b", 2]],這樣每次拿到數(shù)組中的一項 ["a",1],利用解構賦值的形式，將數(shù)組第一項賦值給 key，第二項賦值給 value。

以上常用的方法：

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

遍歷對象使用 Object.keys

創(chuàng)建對象使用 Object.create

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