ES6学习

Object.assign()

用法一：合并多个对象
const obj1 = {aa:1}
const obj2 = {bb:2}
const obj3 = {cc:3}
const obj = Object.assign(obj1, obj2, obj3) // {a:1, b:2, c:3}

注意：1.如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。
     2.如果只有一个参数，Object.assign会直接返回该参数。
     3.如果该参数不是对象，则会先转成对象，然后返回。
     4.由于undefined和null无法转成对象，所以如果它们作为参数，就会报错。
     5.如果非对象参数出现在源对象的位置（即非首参数），那么处理规则有所不同。首先，这些参数都会转成对象，如果无法转成对象，就会跳过。这意味着，如果undefined和null不在首参数，就不会报错。其他类型的值（即数值、字符串和布尔值）不在首参数，也不会报错。
     let obj = {a: 1};
     Object.assign(obj, undefined) === obj // true
     Object.assign(obj, null) === obj // true

用法二：克隆对象（浅拷贝：如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。）
const obj = { name: '张三' ,age: 20}
const obj1 = Object.assign({},obj)

注意：1.同名属性的替换，对于这种嵌套的对象，一旦遇到同名属性，Object.assign的处理方法是替换，而不是添加。
      const target = { a: { b: 'c', d: 'e' } }
      const source = { a: { b: 'hello' } }
      Object.assign(target, source) //{ a: { b: 'hello' } }
      2.数组的处理：把数组视为属性名为 0、1、2 的对象，因此源数组的 0 号属性4覆盖了目标数组的 0 号属性1
      Object.assign([1, 2, 3], [4, 5]) // [4, 5, 3]
      3.取值函数的处理:不会复制这个取值函数，只会拿到值以后，将这个值复制过去。
      const source = { get foo() { return 1 }};
      const target = {};
      Object.assign(target, source) // { foo: 1 }

用法三：为对象添加多个方法(直接将两个函数放在大括号中，再使用assign方法添加到SomeClass.prototype之中。)
Object.assign(SomeClass.prototype, {
  someMethod(arg1, arg2) {},
  anotherMethod() {}
});​
// 原来的方法
SomeClass.prototype.someMethod = function (arg1, arg2) {​};
SomeClass.prototype.anotherMethod = function () {};

用法四：为对象添加属性（将x属性和y属性添加到Point类的对象实例。）
class Point {
  constructor(x, y) { Object.assign(this, {x, y});}
}

对象的声明：const / Object.freeze

Object.freeze()：该方法可以冻结一个对象，对象再也不能被修改，不能向这个对象添加新的属性，不能删除已有属性，不能修改该对象已有属性的可枚举性、可配置性、可写性，以及不能修改已有属性的值。
1.常量无法改变
2.数据类型可改变
const obj = {name: '游荡de蝌蚪', age: 18}
obj.age = 19
obj // {name: '游荡de蝌蚪', age: 19}

const person = {name: '游荡de蝌蚪',hobby: ['game', 'coding']}
Object.freeze(person)
person.hobby[1] = 'eat'
person // { name: '游荡de蝌蚪', hobby: [ 'game', 'eat' ] }

解构赋值

1.只要等号两边的模式相同，左边的变量就会被赋予对应的值。（模式匹配）
例：let [ , , third] = ["foo", "bar", "baz"];
    third // "baz"
    let [head, ...tail] = [1, 2, 3, 4];
    head // 1
    tail // [2, 3, 4]
2.如果解构不成功，变量的值就等于undefined。
例：let [x, y, ...z] = ['a'];
    x // "a"
    y // undefined
    z // []
3.不完全解构，即等号左边的模式，只匹配一部分的等号右边的数组
例：let [a, [b], d] = [1, [2, 3], 4];
    a // 1
    b // 2
    d // 4
4.等号的右边不是数组（或者严格地说，不是可遍历的结构），那么将会报错。
例：let [foo] = 1; // 报错
   let [foo] = false;
   let [foo] = NaN;
   let [foo] = undefined;
   let [foo] = null;
   let [foo] = {};
5.对于 Set 结构，也可以使用数组的解构赋值。
例：let [x, y, z] = new Set(['a', 'b', 'c']);
    x // "a"
6.默认值可以引用解构赋值的其他变量，但该变量必须已经声明。
例：let [x = 1, y = x] = [2];    // x=2; y=2
    let [x = 1, y = x] = [1, 2]; // x=1; y=2
    let x;
    if ([1][0] === undefined) {
        x = f();
    } else {
        x = [1][0];
    }
    console.log(x) // x=1
7.对象解构（数组的元素是按次序排列的，变量的取值由它的位置决定；而对象的属性没有次序，变量必须与属性同名，才能取到正确的值）