Object

• 靜態方法

// 靜態方法：
Object.assign()// 將多有可列舉屬性的值從一個或多個源物件複製到目標物件。返回目標物件。
Object.create()// 使用現有的物件來提供新建立的物件的_proto_。返回一個帶著指定原型物件的和屬性的新物件

Object.defineProperties(obj, props)// 直接在一個物件上定義新的屬性或修改現有屬性，返回該物件
Object.create()// 使用現有的物件來提供新建立的物件的_proto_。返回值：一個帶著指定原型物件的和屬性的新物件
Object.defineProperties(obj,props)
    // e.g
 

    let obj = {};
    Object.defineProperties(obj,{
        'property1': {
            value: true,
            writable: true
        },
        'property2': {
            value: 'hello',
            writable: false
        }
    })

Object.defineProperty(obj, prop, descriptor);
    // 使用_proto_
    let
 
 obj2 = {};
    let descriptor = Object.create(null);// 沒有繼承屬性
    // 預設沒有enumerable、configurable、writable
    descriptor.value = 'static';
    descriptor.defineProperty(obj2, 'key', descriptor);

    // 顯式
    object.defineProperty(obj, "key", {
        enmurable: false,
        configurable: false,
        writable: false
 
,
        value: "static"
    }),

    // 迴圈使用同一物件
    function withValue(value){
        let d = withValue.d || (
            withValue.d = {
                enmurable: false,
                configurable: false,
                writable: false,
                value: null 
            }
        );
        d.value = value;
        return d;
    }
    Object.defineProperty(obj2, "key", withValue("static"));// {key: "static"}key: "static"__proto__: Object


Object.entries(obj)// 返回一個給定物件自身可列舉屬性的鍵值對陣列，其排列與使用for...in 遍歷該物件時返回的順序一直(區別:for-in迴圈也列舉原型鏈中的屬性) 
    //e.g
    const objEntries = { foo: 'bar', baz: 42};
    console.log(Object.entries(objEntries));// ["foo", "bar"]、["baz", 42]

Object.freeze(obj)// 凍結一個物件(不能向這個物件新增新的屬性，不能修改已有屬性的值，不能修改該物件已有屬性的可列舉性、可配置性、可寫性)返回被凍結物件
Object.isFrozen(obj);// determines if an object is frozen
    // e.g
    const obj = {
        property1: 42
    };
    Object.isFrozen(obj)// false


Object.getOwnPropertyDescriptor(obj, prop)// 返回指定物件上一個自由屬性對應的屬性描述符。(自有屬性:不需要從原型鏈上查詢直接賦予該物件的屬性)
Object.getOwnPropertyDescriptors(obj)

Object.getOwnPropertyNames(obj)// 返回一個由指定物件的所有自身屬性的屬性名(包括不可列舉屬性但不包括Symbol值作為名稱的屬性)組成的陣列。
Object.getOwnPropertySymbols(obj)// 返回一個給定物件自身的所有Symbol屬性的陣列。

Object.getPrototypeOf(obj)// 返回指定物件的原型(內部[[Prototype]]屬性的值);返回值:給定物件的原型.如果沒有繼承屬性，則返回null；
Object.setPrototypeOf(obj,prototype)// 

Object.is(value1,value2)// 返回值：表示兩個引數是否相同的Boolean。
/*
 兩個值相同的情況：
    *兩個值都是undefined；
    *都是null；
    *都是true或者false
    *都是由相同個數的字元按照相同的順序組成的字串
    *都指向同一個物件
    *都是數字並且(都是+0||都是-0||都是NaN||都是除0和NaN外的其他同一個數字)
*/
// 特例
    Object.is(0, -0);// false
    Object.is(-0, -0);// true
    Object.is(NaN, 0/0);// true

Object.isExtensible(obj)// 判斷一個物件是否是可擴充套件的(是否可以在它上面新增新的屬性)。返回值：Boolean；
Object.preventExtensions(obj)// 讓一份物件變的不可擴充套件，也就是永遠不能再新增新的屬性。

Object.isSealed(obj)// 判斷一個物件是否被密封。返回值：Boolean；(密封物件是指那些不可擴充套件的，並且自身屬性都不可配置且因此不可刪除(但不一定是不可寫)的物件)
Object.seal(obj)

Object.keys(obj)// 返回一個由一個給定物件的自身可列舉屬性組成的陣列，陣列中屬性的排列屬性和使用for...in迴圈遍歷該物件時返回的順序抑制
Object.values(obj)// 屬性值
/*
Object.assign()
<1> 淺拷貝；得到的目標物件是對原物件的引用，原物件的熱河變化會反映到目標物件上；
<2>同名屬性替換；例子中 obj.c = 4；
<3可以處理陣列，將陣列視為物件；
*/
const obj = {
    a: 1,
    b: 2,
    c: 3,
}
const obj1 = Object.assign(obj, { c: 4, d: 5} )
console.log(obj1);//{ a: 1, b: 2, c: 4, d: 5 }
//克隆到一個空物件
function clone(orign){
    return Object.assign({},orign);
}
//克隆並保持繼承鏈
function clonePrototype(orign){
    let originProto = Object.getPrototypeOf(orign);
    return Object.assign(Object.create(originProto),orign);
}
Object.defineProperty(obj,"key",{
    name: "Leila",
    age: 22
})
let target = clone(obj);//false
target = clonePrototype(obj)//
console.log(Object.getPrototypeOf("key") );



Object.create(proto/*新建立物件的原型物件*/,[PropertiesObject/*null or 一個物件*/])

// 使用Object.create 實現類式繼承
// Shape - 父類(superclass)
function Shape(){
    this.x = 0;
    this.y = 0;
}

// 父類的方法
Shape.prototype.move = (x, y) => {
    this.x += x;
    this.y += y;
    console.info(' Shape moved.')
}

// Rectangle - 子類
function Rectangle(){
    Shape.call(this);// call super constructor; (call詳解留後)
}

// 子類繼承父類
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;

let rect = new Rectangle();

console.log('Is rect an instance of Rectangle? ', rect instanceof Rectangle); // Is rect an instance of Rectangle?  true
console.log('Is rect an instance of Shape?', rect instanceof Shape);// Is rect an instance of Shape? true
rect.move(1,1); // Shape moved.

// 使用Object.create的propertyObject引數
let o;
// 建立原型為null的空物件；
o = Object.create(null);

o = {}
// 以字面量方式建立的空物件相當於
o = Object.create(Object.prototype);

o = Object.create(Object.prototype,{
    // foo會成為所建立物件的資料屬性
    foo: {
        writable: true,
        configurable: true,
        value: 'hello'
    },
    bar: {
        configurable: false,
        get: () => { return 10; },
        set: (value) => {console.log("Setting`o.bar`to", value);}
    }
});
function Constructor(){};
o = new Constructor();
// 上面這一句相當於
o = Object.create(constructor.prototype);
// 如果在constructor函式中有一些初始化程式碼，Object.create不能執行那些程式碼

// 建立一個以另一個空物件為原型，且擁有一個屬性p的物件
o = Object.create({}, { p: {value: 42}});

// 省略了的屬性特性預設為false，所以屬性p是不可寫的，不可列舉，不可配置
o.p = 24;
console.log(o.p)// 42

• 例項方法 (去掉了MDN不支援的方法)

// 例項化方法
Object.prototype.hasOwnProperty(prop)// 返回布林值，指示物件自身屬性是否具有指定的屬性； 
Object.prototype.isPrototypeOf(obj)// 測試一個物件是否存在於另一個物件的原型鏈上；
Object.prototype.propertyIsEnumerable(prop)// 返回布林值表示指定的屬性是否可列舉；
Object.prototype.toLocaleString();
Object.prototype.toString();
Object.prototype.valueOf()// 返回指定物件的原始值