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

標(biāo)準(zhǔn)構(gòu)造器函數(shù)Object可能是JavaScript最重要的對(duì)象之一，盡管我們從來(lái)不會(huì)直接調(diào)用它。每當(dāng)使用一個(gè)對(duì)象直接量時(shí)，都會(huì)隱式調(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的一個(gè)實(shí)例，而a的原型是Object.prototype。我們用對(duì)象字面量創(chuàng)建的每個(gè)對(duì)象都會(huì)獲得由Object.prototype定義的行為

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

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

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

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

    var arr = [1,2,3];        
    console.log(Object(arr));            // 把原對(duì)象返回了
    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
    
    // 一個(gè)判斷是否是對(duì)象的函數(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() 方法會(huì)返回一個(gè)由一個(gè)給定對(duì)象的自身可枚舉屬性組成的數(shù)組，數(shù)組中屬性名的排列順序和使用 for...in 循環(huán)遍歷該對(duì)象時(shí)返回的順序一致 （兩者的主要區(qū)別是 一個(gè) for-in 循環(huán)還會(huì)枚舉其原型鏈上的屬性）。

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

Object.getOwnPropertyNames 返回一個(gè)數(shù)組，該數(shù)組對(duì)元素是 obj 自身?yè)碛械拿杜e或不可枚舉屬性名稱字符串。 數(shù)組中枚舉屬性的順序與通過(guò) for...in 循環(huán)（或 Object.keys）迭代該對(duì)象屬性時(shí)一致。 數(shù)組中不可枚舉屬性的順序未定義。

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

    // 無(wú)法枚舉到原型鏈中的屬性
    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"
        
    // 對(duì)于數(shù)組對(duì)象（length屬性為不可枚舉）
    var arr = ["a","b","c"];
    console.log(
        Object.getOwnPropertyNames(arr)
    );                                    // "0,1,2,length"
    
    // 對(duì)于隨機(jī)排列的數(shù)組對(duì)象
    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對(duì)象的方法 Object.getOwnPropertyNames():只有它可以享有Enumerable的"豁免權(quán)"，不管如何設(shè)置只要是這個(gè)對(duì)象上的自有屬性都可以枚舉到！ 對(duì)象屬性控制相關(guān)方法 四個(gè)相關(guān)的方法在這里先列出，這里要要提到數(shù)據(jù)屬性和訪問(wèn)器屬性

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

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

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

Object.getOwnPropertyDescriptor() 返回指定對(duì)象上一個(gè)自有屬性對(duì)應(yīng)的屬性描述符。（自有屬性指的是直接賦予該對(duì)象的屬性，不需要從原型鏈上進(jìn)行查找的屬性）
    // 采用Object.defineProperty定義的屬性，如果不顯示定義
    // enumerable,configurable,writable值默認(rèn)為false(與對(duì)象字面量相反)
    var obj = {};
    Object.defineProperty(obj,"x",{
        value:"obj.x"
    });
    
    
    // 使用Object.getOwnPropertyDescriptor()獲取屬性對(duì)象
    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() 方法直接在一個(gè)對(duì)象上定義新的屬性或修改現(xiàn)有屬性，并返回該對(duì)象。

    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ù)，就能夠定義一個(gè)只能夠通過(guò)訪問(wèn)器getter和setter來(lái)訪問(wèn)值的屬性。訪問(wèn)器與value屬性是互相排斥的，也就是說(shuō)，如果指定了value屬性的值，訪問(wèn)器（包括get和set）就會(huì)失效；反之，如果指定了訪問(wèn)器（get或set中的某一個(gè)亦或是都存在），value屬性就會(huì)失效。
《JS高程3》：不一定非要同時(shí)指定getter和setter。只指定getter意味著屬性是不能寫(xiě)，嘗試寫(xiě)入屬性會(huì)被忽略。在嚴(yán)格模式下，嘗試寫(xiě)入只指定了getter函數(shù)的的屬性會(huì)拋出錯(cuò)誤。類似地，沒(méi)有指定setter函數(shù)的屬性也不能讀，否則在非嚴(yán)格模式下會(huì)返回undefined，在嚴(yán)格模式下會(huì)拋出錯(cuò)誤。
    var obj = {_x:10};
    
    // 定義一個(gè)訪問(wèn)器屬性
    Object.defineProperty(obj,"x",{
        get:function () {
            return this._x
        }
    })
    // 讀取obj.x會(huì)隱式調(diào)用訪問(wèn)器屬性,返回obj._x的值（下劃線代表此屬性只能通過(guò)訪問(wèn)器讀寫(xiě)）
    console.log(obj.x);            // 10
    
    // 嘗試為訪問(wèn)器屬性賦值
    // 直接賦值
    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
    
    // 不可寫(xiě)的原因是value屬性與訪問(wèn)器屬性沖突，即（get、set）與value屬性沖突
    
    // 可以通過(guò)查看attributes屬性，判斷屬性是否是訪問(wèn)器屬性還是數(shù)據(jù)屬性，存在set或者get的是訪問(wèn)器屬性

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

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

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