ES6复习——数据类型(1)：Object

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()// 返回指定对象的原始值

内容参考MDN：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript