ES6 对象字面量，属性名表达式，拓展运算符，对象新方法Object.assign（），Object.is（）

 对象字面量

属性简洁表示方法--ES6允许对象的属性直接写变量，这时候属性名是变量名，属性值是变量值。

{
    let name = '张三'
    let age = 19
    
    // let person = {name:name,age:age} //{ name: '张三', age: 19 }
    // 如果属性名和值相等，则值名可以省略不写
    let person = {name,age}  //{ name: '张三', age: 19 }
    console.log(person); 
}

---

ES6中方法名也可以简写

{
    // es5中对象名的方法写法
    let per = {
        sayHi:function(){
            console.log('你好');
        }
    }
    per.sayHi();  // 你好
    
}
{
    // es6中对象名的方法写法(可以把:function去掉)
    let per = {
        sayHi(){
            console.log('你好');
        }
    }
    per.sayHi()   //  你好
}

---

es6中对象的方法如果是Generator 函数，则要在前面加一个星号:*

{
     // es5中Generator函数的写法
    let per = {
        myGenretor:function*(){
            yield  '下午好'
        }
    }
    let res = per.myGenretor();
    console.log(res.next());  // { value: '下午好', done: false }
    
}

{
    // es6中Generator函数的写法 (星号要写在前面)
    let per = {
        *myGenretor(){
            yield  '下午好'
        }
    }
    let res = per.myGenretor()
    console.log(res.next()); // { value: '下午好', done: false }
    
}

---

属性名表达式
es6中允许运用属性名表达式

{
    // ES6允许用表达式作为属性名，但是一定要将表达式放在方括号内。
    // 注意： 属性名表达式可以 用在定义设置对象的属性名上
    //         也可以用在 定义设置对象的方法名上
    let per = {
        ['na'+'me']:'李四',
        ['say'+'Hi'](){
            console.log('你好啊');
        }
    }
    console.log(per.name); // 李四
    per.sayHi()  // 你好啊
    
}

注意点：属性的简洁表示法和属性名表达式不能同时使用，否则会报错。

{
      let name = 'name'
      let per = {
          [name]
      };
      console.log(per);  // SyntaxError: Unexpected token '}'
}

但如果是先用了简洁表示后再运用属性名表达式，则会继续拼接新的属性名。

{
    let name = 'hello'
    let per = {
        ['hello'+'hi']:'你好啊'
    }
    console.log(per);  // { hellohi: '你好啊' }
}

---

对象的拓展运算符

拓展运算符（...）用于取出参数对象所有可遍历属性然后拷贝到当前对象。

{
    // 复制一个对象
    let per = {id:'1001',name:'小三'}
    let per1 = {...per}
    console.log(per1);  //  { id: '1001', name: '小三' }

    // 复制一个新对象后再去操作他
    console.log(per1.id);  //  1001
}

合并两个或多个对象

// 合并两个或多个对象
{
    let per = {id:'1001',age:10}
    let per2 = {height:'1.7'}

    let per3 = {...per,...per2}
    console.log(per3);  // { id: '1001', age: 10, height: '1.7' }
}

// 注意点： 自定义属性在拓展运算符后面时，属性名相同则会覆盖掉前面的
{
    let per = {id:'1002',name:'小四'}
    let per1 = {...per,name:'小李',height:'1.88'}
    console.log(per1);  // { id: '1002', name: '小李', height: '1.88' }

    // 同理，两个（或多个）数组进行合并时，属性名相同时，后面的会覆盖前面的
    let per2 = {sex:'男',age:19}
    let per3 = {sex:'女'}
    let per4 = {...per2,...per3}
    console.log(per4);  // { sex: '女', age: 19 }

}

---

对象的新方法

Object.assign(target, source_1, ···)

用于将源对象的所有可枚举属性复制到目标对象中。

    // 基本用法
{
    let per = {id:1}
    let per1 = {name:'李四'}
    let per2 = {age:19}

    // 第一个参数为目标对象，后面的参数是源对象
    Object.assign(per,per1,per2)
    console.log(per);  // { id: 1, name: '李四', age: 19 }
}

如果该函数只有一个参数，当参数为对象时，直接返回该对象；

{
    // 如果该函数只有一个参数，当参数为对象时，直接返回该对象；
    let str = 'hello'
    console.log(Object.assign(str),typeof(Object.assign(str)));
    // [String: 'hello'] object
}

如果目标对象和源对象有同名属性，或者多个源对象有同名属性，则后面的属性会覆盖前面的属性。

{
    let per1 = {id:1001,name:'张三'}
    let per2 = {id:1002,age:18}
    let per3 = {age:20,height:'1.88'}
    Object.assign(per1,per2,per3)
    console.log(per1);  // { id: 1002, name: '张三', age: 20, height: '1.88' }
}

因为 null 和 undefined 不能转化为对象，所以会报错:

{
    console.log(Object.assign(null));
    //TypeError: Cannot convert undefined or null to object
}

{
    console.log(Object.assign(undefined));
   //TypeError: Cannot convert undefined or null to object
}

当参数不止一个且第一个不为null或undefined时（不为目标对象时）会跳过，不报错

{
    let per = {id:1001,name:'张三'}
    let per2 = {age:10}
    Object.assign(per,undefined,null,per2)
    console.log(per); // { id: 1001, name: '张三', age: 10 }
}

注意点：assgin属性拷贝是浅拷贝

注意：浅拷贝，拷贝的是数据

{
    let per = {a:1,b:2}
    let obj = {c:3}
    Object.assign(obj,per)
    // 当你给c重新赋值属性时，会覆盖原先的值
    obj.c = 10
    console.log(obj.c); // 10
}

---

同属性名替换

{
    let per = {a:{b:'hi'}}
    let per1 = {a:{c:'haha',d:1}}
    Object.assign(per,per1)
    console.log(per); // { a: { c: 'haha', d: 1 } }
}

assign对于数组的处理

会先把数组处理成对象，[1,2]变成{0:1,1:2},然后再进行复制，所以源对象上的0位置会覆盖掉目标对象上的0位置。

{
    let arr = [1,2,3,4]
    let arr1 = [5,6,7,8]
    Object.assign(arr,arr1)
    console.log(arr); // [ 5, 6, 7, 8 ]
}

---

Object.is(value1, value2)

用来比较两个值是否严格相等，与（===）基本类似

基本用法

{
    // 基本数据类型
    console.log(Object.is(1,1));  // true
    console.log(Object.is('hi','hi'));  // true
    console.log(Object.is('hi','hello'));  // false

    // 复合数据类型，两个数组或对象，只是值相同
    console.log(Object.is([1],[1]));    // false
    console.log(Object.is({id:1,id:1}));   //false
}

与（===）的区别

{
    // 1.-0不等于+0
    console.log(Object.is(-0,+0));   //false 
    console.log(-0===+0);   // true

    // 2. NaN 等于本身
    console.log(Object.is(NaN,NaN));    // true
    console.log(NaN===NaN);  //false 
}

部分内容来自菜鸟教程，侵删