ES6中对象的新增方法

1. Object.is():用来比较两个值，是否严格相等

            console.log(Object.is(123,123));
            console.log(Object.is("123",123));
            // 与===的区别：NaN  -0===+0
            console.log(NaN===NaN);//FALSE
            console.log(Object.is(NaN,NaN));//true

            console.log(-0===+0);//true
            console.log(Object.is(-0,+0));//false

2. Object.assign(target，source...):用于对象的合并，将原对象的可枚举属性返回到目标对象

            // target目标对象  

            // source... 原对象（target后面的对象）
 

            let o1={a:1};
            let o2={b:2,a:4};//出现同名的值，后面的会将钱前面的值覆盖掉
            let o3={c:3,d:[0,1]};
            let o=Object.assign(o1,o2,o3);//o1是目标对象
            console.log(o);
            console.log(o1);
            console.log(o==o1);//存的是地址，所以相等

            o=Object.assign(o1);//如果只有目标对象，直接将目标对象返回
            console.log(o);

            // 如果目标对象不是对象，先将其转成对象，再进行合并
            // 目标对象不能是null 和undefined，会报错（null 和undefined不能转对象）
            // 目标对象是数子，会转成空对象
            o=Object.assign("str",o2);
            o=Object.assign(33,o2);

            // 当原对象不是对象，会将其转成对象，再进行合并
            o=Object.assign(o2,11)
            console.log(o);
            o=Object.assign(o2,"str")
            console.log(o);

            // 进行对象的拷贝，只能拷贝自身的属性，继承的和不可枚举的不可拷贝
            o=Object.assign({},o3)
            console.log(o);
            o.c=5;
            console.log(o3);//得到的是目标对象，不会印象原对象
            o.d[0]=100;
            console.log(o3);//o3收到影响，浅拷贝
            console.log(o);//o3收到影响，浅拷贝

            // 设置默认值
            const DEFAULTS = {
                logLevel: 0,
                outputFormat: 'html'
                     };
                function processContent(options) {
                options = Object.assign({}, DEFAULTS, options);
                console.log(options);
                // ...
                }

            o1={c:1}
            o2={b:2,a:4}

3.  Object.getOwnPropertyDescriptors(o2) 返回这个对象的所有属性的描述对象

            console.log(Object.getOwnPropertyDescriptors(o2));
            Object.setPrototypeOf(o2,o1)//将o1 作为o2的原型对象
            console.log(Object.getOwnPropertyDescriptors(o2));//不能获取对象继承的属性的属性描述对象

4. Object.defineProperties(对象，要修改的描述对象)  直接在一对象上 定义/修改 一个或多个新的属性

            let x={
                name:"x",
                age:19
            }
            Object.defineProperties(x,{
                y:{//添加
                    value:"y",
                    enumerable:true
                },
                age:{//修改
                    value:20
                }
            })
            console.log(x);//{name: 'x', age: 20, y: 'y'}


            // 拷贝obj  该方法可以实现对象的拷贝可以复制到对象中的getter和setter
            let obj={
                age:18,
                get name(){
                    console.log(123);
                },
                set name(a){
                    console.log(456);
                }
            }
            let obj1=Object.defineProperties({},Object.getOwnPropertyDescriptors(obj));
            console.log(obj1);
            console.log(Object.getOwnPropertyDescriptors(obj1));

5. Object.create(参数1[,参数2]) 创建对象

            // 参数1：新建对象的原型对象

            // 参数2：属性的属性描述对象

            o=Object.create({ccc:111},{
                aaa:{
                    value:111,
                    writable:true,
                },
                bbb:{
                    value:222,
                    writable:true,
                }
            })
            console.log(o);//{aaa: 111, bbb: 222}
            console.log(o.ccc);
            
            // 通过Object.create拷贝对象-----浅拷贝
            let q={
                name:"q",
                age:10
            }
            // Object.getPrototypeOf(q)=q.__proto__
            // 可以克隆到继承的属性描述对象（原型链是同一条，可使用继承的属性）
            let qq=Object.create(q.__proto__,{
                name:{
                    value:"q"
                },
                age:{
                    value:10
                }
            })
            console.log(qq);
            // console.log(qq.__proto__==q.__proto__);
            // 使用Object.setPrototypeOf()（写操作）、Object.getPrototypeOf()（读操作）、Object.create()（生成操作）代替obj.__proto__。


            // 方法2
            // const obj3 = Object.create(
            // prot,//原型对象
            // Object.getOwnPropertyDescriptors({
            //     foo: 123,
            // })
            // );

6. Object.fromEntries()方法是Object.entries()的逆操作，用于将一个键值对数组转为对象。

        Object.fromEntries([
        ['foo', 'bar'],
        ['baz', 42]
        ])
        // { foo: "bar", baz: 42 }