ES6系列之對象方法總結

屬性

Object.prototype.value：設置屬性的值
Object.prototype.writable：是否可修改屬性的值；默認爲false
Object.prototype.enumerable：是否可枚舉屬性；默認爲false
Object.prototype.configurable：是否可修改屬性的特性；默認爲false

對象建立

Object.create(prototype[,propertiesObject])

使用指定的原型對象及其屬性去建立一個新的對象。

var parent = {
    x : 1,
    y : 1
}
var child = Object.create(parent,{
    z : {                           // z會成爲建立對象的屬性
        writable:true,
        configurable:true,
        value: "newAdd"
    }
});
console.log(child);               //{z: "newAdd"}
console.log(hild.__proto__);      //{x: 1, y: 1}

對象屬性操做

Object.defineProperty(obj, prop, descriptor)

在一個對象上定義一個新屬性，或者修改一個對象的現有屬性， 並返回這個對象。

obj：必需。目標對象 
prop：必需。需定義或修改的屬性的名字
descriptor：必需。將被定義或修改的屬性的描述符

返回值：
傳入函數的對象。即第一個參數obj

var obj = {
    test:"hello"
}
Object.defineProperty(obj,"haha",{
    configurable: true,
    enumerable: true,
    value: "kkk",
    writable: true
});

// {
    haha: "kkk"
    test: "hello"
   }

屬性描述符

對象裏目前存在的屬性描述符有兩種主要形式：

• 數據描述符: 一個擁有可寫或不可寫值的屬性
• 存取描述符: 由一對 getter-setter 函數功能來描述的屬性

描述符必須是兩種形式之一；不能同時是二者。

數據描述符和存取描述符均具備如下可選鍵值：

configurable
  true，該屬性描述符纔可以被改變，同時該屬性也能從對應的對象上被刪除。默認爲 false。
enumerable    
    true，該屬性纔可以出如今對象的枚舉屬性中。默認爲 false。

數據描述符同時具備如下可選鍵值：

value    
    該屬性對應的值。能夠是任何有效的 JavaScript 值（數值，對象，函數等）。默認爲 undefined。
writable    
    true，該屬性才能被賦值運算符改變。默認爲 false。

存取描述符同時具備如下可選鍵值:

get    
    一個給屬性提供 getter 的方法，若是沒有 getter 則爲 undefined。該方法返回值被用做屬性值。默認爲 undefined。
set    
    一個給屬性提供 setter 的方法，若是沒有 setter 則爲 undefined。該方法將接受惟一參數，並將該參數的新值分配給該屬性。默認爲 undefined。

// get & set
var obj = {};
var initValue = 'hello';
Object.defineProperty(obj,"newKey",{
    get:function (){
        return initValue;    
    },
    set:function (value){
        initValue = value;
    }
});

obj.newKey   //"hello"
obj.newKey = "haha";   //"haha"
obj.newKey     //"haha"   

// set
var obj1 = {};
var initValue1 = 'hello';
Object.defineProperty(obj1,"newKey",{
    set:function (value){
        initValue1 = value;
    }
});

obj1.newKey   //undefined
obj1.newKey = "haha";   //"haha"
obj1.newKey   //undefined

// get
var obj2 = {};
var initValue2 = 'hello';
Object.defineProperty(obj2,"newKey",{   
    get:function (){
        return initValue2;    
    },
});

obj2.newKey     //"hello"
obj2.newKey = "haha";    //"haha"
obj2.newKey    //"hello"

Object.defineProperties(obj, props)

直接在一個對象上定義新的屬性或修改現有屬性，並返回該對象。

var obj = {};
Object.defineProperties(obj, {
  'property1': {
    value: true,
    writable: true
  },
  'property2': {
    value: 'Hello',
    writable: false
  }
});
console.log(obj)   // {property1: true, property2: "Hello"}

Object.getOwnPropertyDescriptor(obj,prop)

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

若是指定的屬性存在於對象上，則返回其屬性描述符對象（property descriptor），不然返回 undefined。

Object.getOwnPropertyDescriptors(obj)

獲取一個對象的全部自身屬性的描述符。

var obj = {
    name : 'js',
    age : 20
}
console.log(Object.getOwnPropertyDescriptors(obj));
// {name: {…}, age: {…}}
// age: {value: 20, writable: true, enumerable: true, configurable: true}
// name: {value: "js", writable: true, enumerable: true, configurable:true}

Object.getOwnPropertyNames()

返回一個由指定對象的全部自身屬性的屬性名（包括不可枚舉屬性但不包括Symbol值做爲名稱的屬性）組成的數組。

var obj = { 0: "a", 1: "b", 2: "c"};
Object.getOwnPropertyNames(obj);              //["0", "1", "2"]

Object.getOwnPropertySymbols()

返回一個給定對象自身的全部 Symbol 屬性的數組。

Object.preventExtensions()

對象不能再添加新的屬性。可修改，刪除現有屬性，不能添加新屬性。

var obj = {
    name :'lilei',
    age : 30 ,
    sex : 'male'
}
obj = Object.preventExtensions(obj);        //{name: "lilei", age: 30, sex: "male"}
obj.name = "hanmeimei";                     //{name: "hanmeimei", age: 30, sex: "male"}
obj.cc = "ee";                              //{name: "hanmeimei", age: 30, sex: "male"}

Object.keys(obj)

返回一個由一個給定對象的自身可枚舉屬性組成的數組，數組中屬性名的排列順序和使用 for...in 循環遍歷該對象時返回的順序一致 （二者的主要區別是 一個 for-in 循環還會枚舉其原型鏈上的屬性）。

var obj = { foo: "bar", baz: 42 },
    keys = Object.keys(obj);
console.log(keys);                    //["foo", "baz"]

Object.values()

方法返回一個給定對象本身的全部可枚舉屬性值的數組，值的順序與使用for...in循環的順序相同 ( 區別在於 for-in 循環枚舉原型鏈中的屬性 )。
Object.values會過濾屬性名爲 Symbol 值的屬性。

var an_obj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.values(an_obj));            //["b", "c", "a"]

Object.entries()

返回一個給定對象自身可枚舉屬性的鍵值對數組，其排列與使用 for...in 循環遍歷該對象時返回的順序一致（區別在於 for-in 循環也枚舉原型鏈中的屬性）。

var obj = { foo: 'bar', baz: 42 };
console.log(Object.entries(obj)); 
//[Array(2), Array(2)]
// [["foo", "bar"], ["baz", 42]]

其餘靜態方法

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

該方法主要用於對象的合併，將源對象source的全部可枚舉屬性合併到目標對象target上,此方法只拷貝源對象的自身屬性，不拷貝繼承的屬性。

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

Object.assign方法實行的是淺拷貝，而不是深拷貝。也就是說，若是源對象某個屬性的值是對象，那麼目標對象拷貝獲得的是這個對象的引用。同名屬性會替換。

Object.getPrototypeOf()

返回指定對象的原型（內部[[Prototype]]屬性的值，即__proto__，而非對象的prototype）。

Object.isPrototypeOf()

判斷一個對象是否存在於另外一個對象的原型鏈上。

Object.setPrototypeOf(obj,prototype)

設置對象的原型對象

Object.is()

判斷兩個值是否相同。

若是下列任何一項成立，則兩個值相同：

• 兩個值都是 undefined
• 兩個值都是 null
• 兩個值都是 true 或者都是 false
• 兩個值是由相同個數的字符按照相同的順序組成的字符串
• 兩個值指向同一個對象
• 兩個值都是數字而且
• 都是正零 +0
• 都是負零 -0
• 都是 NaN
• 都是除零和 NaN 外的其它同一個數字

Object.is([], []);           // false

Object.freeze()

凍結一個對象，凍結指的是不能向這個對象添加新的屬性，不能修改其已有屬性的值，不能刪除已有屬性，以及不能修改該對象已有屬性的可枚舉性、可配置性、可寫性。也就是說，這個對象永遠是不可變的。該方法返回被凍結的對象。

var obj = {
  prop: function() {},
  foo: 'bar'
};
Object.freeze(obj);           //{prop: ƒ, foo: "bar"}
obj.foo = 'eee';
console.log(obj);             //{prop: ƒ, foo: "bar"}

Object.isFrozen()

判斷一個對象是否被凍結。

Object.isExtensible()

判斷對象是不是可擴展的，Object.preventExtensions，Object.seal 或 Object.freeze 方法均可以標記一個對象爲不可擴展（non-extensible）。

Object.seal()

Object.seal() 方法可讓一個對象密封，並返回被密封后的對象。密封一個對象會讓這個對象變的不能添加新屬性，且全部已有屬性會變的不可配置。屬性不可配置的效果就是屬性變的不可刪除，以及一個數據屬性不能被從新定義成爲訪問器屬性，或者反之。但屬性的值仍然能夠修改。嘗試刪除一個密封對象的屬性或者將某個密封對象的屬性從數據屬性轉換成訪問器屬性，結果會靜默失敗或拋出TypeError 異常. 不會影響從原型鏈上繼承的屬性。但 proto ( ) 屬性的值也會不能修改。

Object.isSealed()

判斷一個對象是否被密封。

實例方法

hasOwnProperty(propertyName)

判斷對象是否擁有一個指定名稱的實例屬性(非繼承)
參數：
①propertyName {string} ：屬性名稱。

返回值：
{bool} 判斷對象是否擁有一個指定名稱的本地定義(非繼承)的屬性；此方法不會檢查對象原型鏈中的屬性。
true ：屬性爲對象的實例屬性，非繼承。
false ：屬性不爲對象的實例屬性。

var o = new Object();
o.name = 'kkkk'; // 定義一個實例屬性
console.log(o.hasOwnProperty('name')); // => true：name屬性爲實例o本身定義的，而非繼承
console.log(o.hasOwnProperty('toString')); // => false：toString爲繼承屬性

isPrototypeOf(obejct)

判斷某個原型是否出如今對象的原型鏈中
語法：
prototype.isPrototypeOf(object)

參數：
①obejct {object} ：被檢測的對象。

返回值：
{bool} 返回某個原型是否出如今對象的原型鏈中
true ：是
false ：不是

var array = [1, 2, 3];
console.log(Array.prototype.isPrototypeOf(array)); // => true ：數組原型
console.log(Object.prototype.isPrototypeOf(array)); // => true ：Object是全部對象的基原型

propertyIsEnumerable(propertyName)

判斷指定名稱的屬性是否爲實例屬性而且是可枚舉的(可用for/in循環枚舉)

參數：
①propertyName {string} ：屬性名稱

返回值：

{bool} 判斷屬性是否爲實例屬性而且是可枚舉的(可用for/in循環枚舉)，不考慮原型鏈中的成員。
true ：是
false ：不是

var array = [1, 2, 3];
array.name = 'Array';
console.log(array.propertyIsEnumerable('name')); // => true ：name屬性爲實例屬性
console.log(array.propertyIsEnumerable('join')); // => false ：join方法繼承自Array
console.log(array.propertyIsEnumerable('length')); // => false ：length屬性繼承自Array
console.log(array.propertyIsEnumerable('toString')); // => false ：toString方法繼承自Object