摘要：需要鏈接標準參考教程對象阮一峰標準構造器函數可能是最重要的對象之一，盡管我們從來不會直接調用它。該方法返回被凍結的對象。

標準構造器函數Object可能是JavaScript最重要的對象之一，盡管我們從來不會直接調用它。每當使用一個對象直接量時，都會隱式調用它：

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

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

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

    // 返回一個Object構造器實例
    var obj = Object();
    console.log(obj instanceof Object);            // true
    
    // 返回一個字符串構造器實例
    var str = Object("string");
    console.log(str instanceof Object);            // true     等價    new String("string")
    
    // 返回一個數字構造器實例
    var num = Object(123);
    console.log(num instanceof Object);            // true        等價    new Number(123)
    
    // 返回一個布爾構造器實例
    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進行typeof結果為對象
    console.log(typeof null);                            // object
    console.log(Object(null) instanceof Object);        // true
    // 對null調用Object方法，返回一個空對象
    
    
    // undefined型也只能取undefined一個值，對undefined進行typeof ，值為undefined
    console.log(typeof undefined);                        // undefined
    console.log(Object(undefined) instanceof Object);    // true
    // 也是返回一個空對象

Object本身當作工具方法使用時，可以將任意值轉為對象。這個方法常用于保證某個值一定是對象。如果參數是原始類型的值，Object方法返回對應的包裝對象的實例

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

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

    // 無法枚舉到原型鏈中的屬性
    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"
        
    // 對于數組對象
    var arr = ["a","b","c"];
    console.log(Object.keys(arr));        // "0,1,2"
    
    // 對于隨機排列的數組對象
    var obj_ramdom = {100:"a",2:"b",50:"c"};
    console.log(Object.keys(obj_ramdom));        // "2,50,100"

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

如果你只要獲取到可枚舉屬性，查看 Object.keys 或用 for...in循環（還會獲取到原型鏈上的可枚舉屬性，不過可以使用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"
        
    // 對于數組對象（length屬性為不可枚舉）
    var arr = ["a","b","c"];
    console.log(
        Object.getOwnPropertyNames(arr)
    );                                    // "0,1,2,length"
    
    // 對于隨機排列的數組對象
    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"
    )

我們如何記憶呢？就記最特殊的！

《JS高程》—— 數據屬性與訪問器屬性

強薦：阮一峰 —— 屬性描述對象

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

Object.getOwnPropertyDescriptor() 返回指定對象上一個自有屬性對應的屬性描述符。（自有屬性指的是直接賦予該對象的屬性，不需要從原型鏈上進行查找的屬性）
    // 采用Object.defineProperty定義的屬性，如果不顯示定義
    // enumerable,configurable,writable值默認為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]+"
")
    }
    // 默認下數據屬性都是false

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

    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默認為false
    // 當然，z屬性的數據屬性都是false

《JavaScript編程全解》：只要將get屬性與set屬性指定為相應的函數，就能夠定義一個只能夠通過訪問器getter和setter來訪問值的屬性。訪問器與value屬性是互相排斥的，也就是說，如果指定了value屬性的值，訪問器（包括get和set）就會失效；反之，如果指定了訪問器（get或set中的某一個亦或是都存在），value屬性就會失效。
《JS高程3》：不一定非要同時指定getter和setter。只指定getter意味著屬性是不能寫，嘗試寫入屬性會被忽略。在嚴格模式下，嘗試寫入只指定了getter函數的的屬性會拋出錯誤。類似地，沒有指定setter函數的屬性也不能讀，否則在非嚴格模式下會返回undefined，在嚴格模式下會拋出錯誤。
    var obj = {_x:10};
    
    // 定義一個訪問器屬性
    Object.defineProperty(obj,"x",{
        get:function () {
            return this._x
        }
    })
    // 讀取obj.x會隱式調用訪問器屬性,返回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屬性，判斷屬性是否是訪問器屬性還是數據屬性，存在set或者get的是訪問器屬性

具體內容請移步至相關知識點進行更深入學習，這里只介紹方法基礎用法

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

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