1.属性的简洁表示法
1.1 ES6允许在对象之中，直接写变量。这时，属性名为变量名, 属性值为变量的值。例如:
const foo = 'bar';
const baz = {foo};
baz // {foo: "bar"}
//等同于
const baz = {foo: foo};
1.2 除了属性简写，方法也可以简写。例如:
const o = { //react native采用的就是这种写法
method() {
return "Hello!";
}
};
// 等同于
const o = {
method: function() {
return "Hello!";
}
};
1.3 如果某个方法的值是一个Generator函数，前面需要加上星号。
const obj = {
* m() {
yield 'hello world';
}
};
2.属性名表达式
2.1 定义对象的属性，有两种方法
1）直接用标识符作为属性名，例如:
obj.foo = true;
2）用表达式作为属性名，这时要将表达式放在方括号之内。例如:
obj['a' + 'bc'] = 123;
2.2 使用字面量方式定义对象，即使用大括号，ES5与ES6存在不同之处:
1）ES5中只能使用方法一（标识符）定义属性。
2）ES6允许把表达式放在方括号内。例如:
let obj = {
[propKey]: true,
['a' + 'bc']: 123
};
2.3 表达式还可以用于定义方法名。例如:
let obj = {
['h' + 'ello']() {
return 'hi';
}
};
obj.hello() // hi
2.4 注意:
1）属性名表达式与简洁表示法，不能同时使用，会报错。例如:
// 报错
const foo = 'bar';
const bar = 'abc';
const baz = { [foo] };
2）属性名表达式如果是一个对象，默认情况下会自动将对象转为字符串[object Object]，这一点要特别小心。例如:
const keyA = {a: 1};
const keyB = {b: 2};
const myObject = {
[keyA]: 'valueA',
[keyB]: 'valueB'
};
myObject // Object {[object Object]: "valueB"}
上面代码中，[keyA]和[keyB]得到的都是[object Object]，所以[keyB]会把[keyA]覆盖掉，而myObject最后只有一个[object Object]属性。
3.方法的name属性
3.1 功能:方法的name属性返回函数名（即方法名）。
3.2 注意:如果对象的方法使用了取值函数（getter）和存值函数（setter），则name属性不是在该方法上面，而是该方法的属性的描述对象的get和set属性上面，返回值是方法名前加上get和set。
3.2 有两种特殊情况:bind方法创造的函数，name属性返回bound加上原函数的名字；Function构造函数创造的函数，name属性返回anonymous。
3.3 如果对象的方法是一个Symbol值，那么name属性返回的是这个Symbol值的描述。
4.Object.is()
4.1 功能:用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致。
4.2 Object.is()与“===”的不同之处，有两个:一是+0不等于-0，二是NaN等于自身。例如:
+0 === -0 //true
NaN === NaN // false
Object.is(+0, -0) // false
Object.is(NaN, NaN) // true
5.Object.assign()
5.1 功能:Object.assign方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）。Object.assign方法的第一个参数是目标对象，后面的参数都是源对象。
5.2 注意点:
1）浅拷贝:Object.assign方法实行的是浅拷贝，而不是深拷贝。也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。
上面代码中，源对象obj1的a属性的值是一个对象，Object.assign拷贝得到的是这个对象的引用。这个对象的任何变化，都会反映到目标对象上面。例如:
const obj1 = {a: {b: 1}};
const obj2 = Object.assign({}, obj1);
obj1.a.b = 2;
obj2.a.b // 2
2）同名属性的替换:对于这种嵌套的对象，一旦遇到同名属性，Object.assign的处理方法是替换，而不是添加。例如:
const target = { a: { b: 'c', d: 'e' } }
const source = { a: { b: 'hello' } }
Object.assign(target, source)
// { a: { b: 'hello' } }
3）数组的处理:Object.assign可以用来处理数组，但是会把数组视为对象。例如:
Object.assign([1, 2, 3], [4, 5])
// [4, 5, 3]
上面代码中，Object.assign把数组视为属性名为0、1、2的对象，因此源数组的0号属性4覆盖了目标数组的0号属性1。
4）取值函数的处理:Object.assign只能进行值的复制，如果要复制的值是一个取值函数，那么将求值后再复制。
const source = { get foo() { return 1 }
};
const target = {};
Object.assign(target, source)
// { foo: 1 }
上面代码中，source对象的foo属性是一个取值函数，Object.assign不会复制这个取值函数，只会拿到值以后，将这个值复制过去。
5.3 常见用途:
1）为对象添加属性
2）为对象添加方法
3）克隆对象
4）合并多个对象
5）为属性指定默认值
1.什么是浅拷贝？
浅复制是对对象地址的复制，并没有开辟新的栈，也就是复制的结果是两个对象指向同一个地址，修改其中一个对象的属性，则另一个对象的属性也会改变，而深复制则是开辟新的栈，两个对象对应两个不同的地址，修改一个对象的属性，不会改变另一个对象的属性。
2.let c = {'a':1, 'b':2};let b = c;这是不是浅拷贝？
let b = c;
b.a = 3;
console.log('===c==='+JSON.stringify(c));//===c==={"a":3,"b":2} 改变b,c也随之改变，浅拷贝
3.怎么进行深拷贝?
使用JSON解析解决:
let c = {a:1,b:2};
let d = JSON.parse(JSON.stringify(c));
d.a = 3
console.log('===c==='+JSON.stringify(c));//===c==={"a":1,"b":2}
console.log('===d==='+JSON.stringify(d));//===d==={"a":3,"b":2}
4.只有这一种解决方案？这种解决方案的优缺点是什么？
不止这种方法，这种方法的优点是简单，缺点是无法复制方法。
let c = {a:1,b:2,func:function(){return 'function'}};
let d = JSON.parse(JSON.stringify(c));
d.a = 3
console.log('===c==='+JSON.stringify(c)+',===c.c==='+c.func);
//===c==={"a":1,"b":2},===c.c===function func() {return 'function';}
console.log('===d==='+JSON.stringify(d)+',===d.c==='+d.func);
//===d==={"a":3,"b":2},===d.c===undefined
https://stackoverflow.com/questions/38416020/deep-copy-in-es6-using-the-spread-sign
