Object上的靜態方法

內置提供了一個對象爲 Object ，也被稱之爲是構造函數，用來建立對象用的。在 javascript 函數也是對象，是一種可被執行的對象，因此稱Object爲對象也是能夠的。掛在函數上的方法，稱之爲靜態方法。

Object.defineProperty()

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

移步閱讀： http://www.javashuo.com/article/p-qasukviu-dp.html

Object.getOwnPropertyDescriptor()

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

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

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

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

返回值是一個對象：

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

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

Object.getOwnPropertyNames()

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

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']

Object.assign()

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

用法：

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'
})

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

Object.create()

此方法用基於傳入的參數對象做爲原型來建立一個新對象。只能接受對象或者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.)

Object.is

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

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

Object.getPrototypeOf()

返回指定對象的原型對象，（內部[[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

Object.setPrototypeOf()

這個方法設置一個指定的對象的原型 ( 即, 內部[[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

Object.keys

方法會返回一個由一個給定對象的自身可枚舉屬性組成的數組，數組中屬性名的排列順序和使用 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']

Object.values

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

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

Object.entries

返回一個給定對象自身可枚舉屬性的鍵值對數組,與使用 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

以上若有誤差歡迎指正學習，謝謝。

來源：http://www.javashuo.com/article/p-xxyhxajk-mq.html