摘要：需要鏈接標(biāo)準(zhǔn)參考教程對象阮一峰標(biāo)準(zhǔn)構(gòu)造器函數(shù)可能是最重要的對象之一，盡管我們從來不會直接調(diào)用它。該方法返回被凍結(jié)的對象。

標(biāo)準(zhǔn)構(gòu)造器函數(shù)Object可能是JavaScript最重要的對象之一，盡管我們從來不會直接調(diào)用它。每當(dāng)使用一個對象直接量時，都會隱式調(diào)用它：

    var a = {};                // 等同于var a = new Object()
    var b = {x:1,y:2};        // 等同于var b = new Object({x:1,y:2});

構(gòu)造函數(shù)定義了數(shù)據(jù)類型，所以表達(dá)式var a = new Object()表明兩件事情：a是Object的一個實(shí)例，而a的原型是Object.prototype。我們用對象字面量創(chuàng)建的每個對象都會獲得由Object.prototype定義的行為

    // 首先，將Object作為構(gòu)造函數(shù)調(diào)用和對象字面量直接定義是等價的
    var o = {};
    var o2 = new Object();
    // 注意這里所說的等價不是指相等，是指其本身和原型繼承相同
    
    // 當(dāng)然也可以
    var a = {};
    var a2 = new Object(a);
    console.log(a===a2);            // true

    // 返回一個Object構(gòu)造器實(shí)例
    var obj = Object();
    console.log(obj instanceof Object);            // true
    
    // 返回一個字符串構(gòu)造器實(shí)例
    var str = Object("string");
    console.log(str instanceof Object);            // true     等價    new String("string")
    
    // 返回一個數(shù)字構(gòu)造器實(shí)例
    var num = Object(123);
    console.log(num instanceof Object);            // true        等價    new Number(123)
    
    // 返回一個布爾構(gòu)造器實(shí)例
    var boo = Object(true);                        // 等價    new Boolean(true)
    var boo2 = Object(false);                    
    console.log(boo instanceof Object && boo2 instanceof Object);    // true
    
    // null存在的意義在于對象引用之中，null值最初含義為：沒有引用任何對象
    // null型只能取null一個值，null值是一個字面量，但是對null進(jìn)行typeof結(jié)果為對象
    console.log(typeof null);                            // object
    console.log(Object(null) instanceof Object);        // true
    // 對null調(diào)用Object方法，返回一個空對象
    
    
    // undefined型也只能取undefined一個值，對undefined進(jìn)行typeof ，值為undefined
    console.log(typeof undefined);                        // undefined
    console.log(Object(undefined) instanceof Object);    // true
    // 也是返回一個空對象

Object本身當(dāng)作工具方法使用時，可以將任意值轉(zhuǎn)為對象。這個方法常用于保證某個值一定是對象。如果參數(shù)是原始類型的值，Object方法返回對應(yīng)的包裝對象的實(shí)例

上面探討的是基礎(chǔ)類型值，那如果是引用類型值呢？

    var arr = [1,2,3];        
    console.log(Object(arr));            // 把原對象返回了
    console.log(Object(arr)===arr);        // true
    
    var fn = function () {};            // 把原函數(shù)返回了
    console.log(Object(fn));            // function () {}
    console.log(Object(fn)===fn);        // true
    
    var obj = {x:"obj.x"};
    console.log(Object(obj));            // [object Object]
    console.log(Object(obj)===obj);        // true
    
    // 一個判斷是否是對象的函數(shù)
    function judgeObj(obj) {
        return Object(obj)===obj? true : false;
    }
    
    console.log(judgeObj([]));            // true
    console.log(judgeObj(true));        // false
    console.log(judgeObj({}));            // true
    console.log(judgeObj(123));            // false

Object.keys() 方法會返回一個由一個給定對象的自身可枚舉屬性組成的數(shù)組，數(shù)組中屬性名的排列順序和使用 for...in 循環(huán)遍歷該對象時返回的順序一致 （兩者的主要區(qū)別是 一個 for-in 循環(huán)還會枚舉其原型鏈上的屬性）。

    // 無法枚舉到原型鏈中的屬性
    var obj = Object.create({y:20});
    obj.x = 10;
    console.log(Object.keys(obj));        // "x"
    
    // 無法枚舉Enumerable為false屬性
    Object.defineProperty(obj,"z",{
        value:"z",
        enumerable:false
    })
    console.log(Object.keys(obj));        // "x"
        
    // 對于數(shù)組對象
    var arr = ["a","b","c"];
    console.log(Object.keys(arr));        // "0,1,2"
    
    // 對于隨機(jī)排列的數(shù)組對象
    var obj_ramdom = {100:"a",2:"b",50:"c"};
    console.log(Object.keys(obj_ramdom));        // "2,50,100"

Object.getOwnPropertyNames 返回一個數(shù)組，該數(shù)組對元素是 obj 自身擁有的枚舉或不可枚舉屬性名稱字符串。 數(shù)組中枚舉屬性的順序與通過 for...in 循環(huán)（或 Object.keys）迭代該對象屬性時一致。 數(shù)組中不可枚舉屬性的順序未定義。

如果你只要獲取到可枚舉屬性，查看 Object.keys 或用 for...in循環(huán)（還會獲取到原型鏈上的可枚舉屬性，不過可以使用hasOwnProperty()方法過濾掉）。

    // 無法枚舉到原型鏈中的屬性
    var obj = Object.create({y:20});
    obj.x = 10;
    console.log(
        Object.getOwnPropertyNames(obj)
    );                                    // "x"
    
    // 可以枚舉Enumerable為false的屬性
    Object.defineProperty(obj,"z",{
        value:"z",
        enumerable:false
    })
    console.log(
        Object.getOwnPropertyNames(obj)
    );                                    // "x,z"
        
    // 對于數(shù)組對象（length屬性為不可枚舉）
    var arr = ["a","b","c"];
    console.log(
        Object.getOwnPropertyNames(arr)
    );                                    // "0,1,2,length"
    
    // 對于隨機(jī)排列的數(shù)組對象
    var obj_ramdom = {100:"a",2:"b",50:"c"};
    console.log(
        Object.getOwnPropertyNames(obj_ramdom)
    );                                    // "2,50,100"

    
    var obj = {x:10,y:20};
    Object.defineProperty(obj,"z",{
        value:30,
        enumerable:false,
    });
    
    // for-in
    for (var a in obj) {
        console.log(a);                     // "x,y"
    }
    
    // Object.keys
    console.log(
        Object.keys(obj)                    // "x,y"
    );
    
    // Object.getOwnPropertyNames()
    console.log(
        Object.getOwnPropertyNames(obj)     // "x,y,z"
    );

    function Test() {
        this.x = 10;
        this.y = 20;
    }
    Test.prototype.z = 30;        // z為原型鏈屬性
    var obj = new Test();
    
    
    // for-in
    for (var a in obj) {
        console.log(a)                         // "x,y,z"
    }
    
    // Object-keys
    console.log(
        Object.keys(obj)                       // "x,y"
    )

    
    // Object.getOwnPropertyNames()
    console.log(
        Object.getOwnPropertyNames(obj)        // "x,y"
    )

我們?nèi)绾斡洃浤?？就記最特殊的?/p> for-in:只有它可以枚舉原型鏈里的屬性，并且它也不是Object對象的方法 Object.getOwnPropertyNames():只有它可以享有Enumerable的"豁免權(quán)"，不管如何設(shè)置只要是這個對象上的自有屬性都可以枚舉到！ 對象屬性控制相關(guān)方法 四個相關(guān)的方法在這里先列出，這里要要提到數(shù)據(jù)屬性和訪問器屬性

《JS高程》—— 數(shù)據(jù)屬性與訪問器屬性

強(qiáng)薦：阮一峰 —— 屬性描述對象

Object.defineProperty() 方法會直接在一個對象上定義一個新屬性，或者修改一個對象的現(xiàn)有屬性， 并返回這個對象。

Object.getOwnPropertyDescriptor() 返回指定對象上一個自有屬性對應(yīng)的屬性描述符。（自有屬性指的是直接賦予該對象的屬性，不需要從原型鏈上進(jìn)行查找的屬性）
    // 采用Object.defineProperty定義的屬性，如果不顯示定義
    // enumerable,configurable,writable值默認(rèn)為false(與對象字面量相反)
    var obj = {};
    Object.defineProperty(obj,"x",{
        value:"obj.x"
    });
    
    
    // 使用Object.getOwnPropertyDescriptor()獲取屬性對象
    var obj_attr = Object.getOwnPropertyDescriptor(obj,"x");
    for (var i in obj_attr) {
        document.write(i+" : "+obj_attr[i]+"
")
    }
    // 默認(rèn)下數(shù)據(jù)屬性都是false

Object.defineProperties() 方法直接在一個對象上定義新的屬性或修改現(xiàn)有屬性，并返回該對象。

    var obj = {};
    Object.defineProperties(obj,{
        x:{
            value:"obj.x",
            writable:true,
            enumerable:true,
            configurable:true
        },
        y:{
            value:"obj.y",
            writable:true,
            enumerable:true,
            configurable:true
        },
        z:{
            value:"obj.z"
        }
    })
    
    console.log(Object.keys(obj));            // "x,y"    z屬性enumerable默認(rèn)為false
    // 當(dāng)然，z屬性的數(shù)據(jù)屬性都是false

《JavaScript編程全解》：只要將get屬性與set屬性指定為相應(yīng)的函數(shù)，就能夠定義一個只能夠通過訪問器getter和setter來訪問值的屬性。訪問器與value屬性是互相排斥的，也就是說，如果指定了value屬性的值，訪問器（包括get和set）就會失效；反之，如果指定了訪問器（get或set中的某一個亦或是都存在），value屬性就會失效。
《JS高程3》：不一定非要同時指定getter和setter。只指定getter意味著屬性是不能寫，嘗試寫入屬性會被忽略。在嚴(yán)格模式下，嘗試寫入只指定了getter函數(shù)的的屬性會拋出錯誤。類似地，沒有指定setter函數(shù)的屬性也不能讀，否則在非嚴(yán)格模式下會返回undefined，在嚴(yán)格模式下會拋出錯誤。
    var obj = {_x:10};
    
    // 定義一個訪問器屬性
    Object.defineProperty(obj,"x",{
        get:function () {
            return this._x
        }
    })
    // 讀取obj.x會隱式調(diào)用訪問器屬性,返回obj._x的值（下劃線代表此屬性只能通過訪問器讀寫）
    console.log(obj.x);            // 10
    
    // 嘗試為訪問器屬性賦值
    // 直接賦值
    obj.x = "aaa";
    console.log(obj.x);            // 10     賦值失敗
    
    // 獲取obj.x的attributes
    var objxAttr = Object.getOwnPropertyDescriptor(obj,"x");
    for (var i in objxAttr) {
        document.write(
            i+" | "+objxAttr[i]+"
"
        )
    }
    // get | function () { return this._x }
    // set | undefined
    // enumerable | false
    // configurable | false
    
    // 不可寫的原因是value屬性與訪問器屬性沖突，即（get、set）與value屬性沖突
    
    // 可以通過查看attributes屬性，判斷屬性是否是訪問器屬性還是數(shù)據(jù)屬性，存在set或者get的是訪問器屬性

具體內(nèi)容請移步至相關(guān)知識點(diǎn)進(jìn)行更深入學(xué)習(xí)，這里只介紹方法基礎(chǔ)用法

如果一個對象可以添加新的屬性，則這個對象是可擴(kuò)展的。preventExtensions 可以讓這個對象變的不可擴(kuò)展，也就是不能再有新的屬性。需要注意的是不可擴(kuò)展的對象的屬性通常仍然可以被刪除。嘗試給一個不可擴(kuò)展對象添加新屬性的操作將會失敗，不過可能是靜默失敗，也可能會拋出 TypeError 異常（嚴(yán)格模式）。
Object.preventExtensions 只能阻止一個對象不能再添加新的自身屬性，仍然可以為該對象的原型添加屬性。然而Object.preventExtensions會阻止一個對象將__proto__屬性重新指向另一個對象。

    // Object.preventExtensions將原對象變的不可擴(kuò)展,并且返回原對象
    var obj = {};
    var obj2 = Object.preventExtensions(obj);
    alert(obj===obj2);            // true
    obj.x = "obj.x";
    alert(obj.x);                // undefined
    
    // 采用對象字面量定義的對象默認(rèn)可擴(kuò)展
    var o = {};
    alert(Object.isExtensible(o));            // true
    // 當(dāng)然，通過調(diào)用方法可以阻止
    Object.preventExtensions(o);
    alert(Object.isExtensible(o));            // false
    
    // 使用Object.defineProperty方法為一個不可擴(kuò)展的對象添加新屬性會拋出異常.
    var o2 = {a:"a"};
    Object.preventExtensions(o2);
    Object.defineProperty(o2,"b",{
        value:"test"            
    })
    // "Uncaught TypeError: Cannot define property:b, object is not extensible."
    
    
    // 一個不可擴(kuò)展對象的原型是不可更改的,__proto__是個非標(biāo)準(zhǔn)魔法屬性,可以更改一個對象的原型.
    var b = Object.preventExtensions({x:1,y:2});
    b.__proto__ = {a:10,b:20};            //  "Uncaught TypeError: #