10.对象的扩展运算符
（1）解构赋值
对象的解构赋值用于从一个对象取值，相当于将所有可遍历的、但尚未被读取的属性，分配到指定的对象上面。所有的键和它们的值，都会拷贝到新对象上面。
let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };x // 1y // 2z // { a: 3, b: 4 }
上面代码中，变量z是解构赋值所在的对象。它获取等号右边的所有尚未读取的键（a和b），将它们连同值一起拷贝过来。
由于解构赋值要求等号右边是一个对象，所以如果等号右边是undefined或null，就会报错，因为它们无法转为对象。
let { x, y, ...z } = null; // 运行时错误let { x, y, ...z } = undefined; // 运行时错误
解构赋值必须是最后一个参数，否则会报错。
let { ...x, y, z } = obj; // 句法错误let { x, ...y, ...z } = obj; // 句法错误
上面代码中，解构赋值不是最后一个参数，所以会报错。
注意，解构赋值的拷贝是浅拷贝，即如果一个键的值是复合类型的值（数组、对象、函数）、那么解构赋值拷贝的是这个值的引用，而不是这个值的副本。
let obj = { a: { b: 1 } };let { ...x } = obj;obj.a.b = 2;x.a.b // 2
上面代码中，x是解构赋值所在的对象，拷贝了对象obj的a属性。a属性引用了一个对象，修改这个对象的值，会影响到解构赋值对它的引用。
另外，解构赋值不会拷贝继承自原型对象的属性。
let o1 = { a: 1 };let o2 = { b: 2 };o2.__proto__ = o1;let { ...o3 } = o2;o3 // { b: 2 }o3.a // undefined
上面代码中，对象o3复制了o2，但是只复制了o2自身的属性，没有复制它的原型对象o1的属性。
下面是另一个例子。
var o = Object.create({ x: 1, y: 2 });o.z = 3;let { x, ...{ y, z } } = o;x // 1y // undefinedz // 3
上面代码中，变量x是单纯的解构赋值，所以可以读取对象o继承的属性；变量y和z是双重解构赋值，只能读取对象o自身的属性，所以只有变量z可以赋值成功。
解构赋值的一个用处，是扩展某个函数的参数，引入其他操作。
function baseFunction({ a, b }) { // ...}function wrapperFunction({ x, y, ...restConfig }) { // 使用x和y参数进行操作 // 其余参数传给原始函数 return baseFunction(restConfig);}
上面代码中，原始函数baseFunction接受a和b作为参数，函数wrapperFunction在baseFunction的基础上进行了扩展，能够接受多余的参数，并且保留原始函数的行为。
（2）扩展运算符
扩展运算符（...）用于取出参数对象的所有可遍历属性，拷贝到当前对象之中。
let z = { a: 3, b: 4 };let n = { ...z };n // { a: 3, b: 4 }
这等同于使用Object.assign方法。
let aClone = { ...a };// 等同于let aClone = Object.assign({}, a);
扩展运算符可以用于合并两个对象。
let ab = { ...a, ...b };// 等同于let ab = Object.assign({}, a, b);
如果用户自定义的属性，放在扩展运算符后面，则扩展运算符内部的同名属性会被覆盖掉。
let aWithOverrides = { ...a, x: 1, y: 2 };// 等同于let aWithOverrides = { ...a, ...{ x: 1, y: 2 } };// 等同于let x = 1, y = 2, aWithOverrides = { ...a, x, y };// 等同于let aWithOverrides = Object.assign({}, a, { x: 1, y: 2 });
上面代码中，a对象的x属性和y属性，拷贝到新对象后会被覆盖掉。
这用来修改现有对象部分的部分属性就很方便了。
let newVersion = { ...previousVersion, name: 'New Name' // Override the name property};
上面代码中，newVersion对象自定义了name属性，其他属性全部复制自previousVersion对象。
如果把自定义属性放在扩展运算符前面，就变成了设置新对象的默认属性值。
let aWithDefaults = { x: 1, y: 2, ...a };// 等同于let aWithDefaults = Object.assign({}, { x: 1, y: 2 }, a);// 等同于let aWithDefaults = Object.assign({ x: 1, y: 2 }, a);
扩展运算符的参数对象之中，如果有取值函数get，这个函数是会执行的。
// 并不会抛出错误，因为x属性只是被定义，但没执行let aWithXGetter = { ...a, get x() { throws new Error('not thrown yet'); }};// 会抛出错误，因为x属性被执行了let runtimeError = { ...a, ...{ get x() { throws new Error('thrown now'); } }};
如果扩展运算符的参数是null或undefined，这两个值会被忽略，不会报错。
let emptyObject = { ...null, ...undefined }; // 不报错

11.object.getOwnPropertyDescirptors()
ES5有一个Object.getOwnPropertyDescriptor方法，返回某个对象属性的描述对象（descriptor）。
var obj = { p: 'a' };Object.getOwnPropertyDescriptor(obj, 'p')// Object { value: "a",// writable: true,// enumerable: true,// configurable: true// }
ES2017 引入了Object.getOwnPropertyDescriptors方法，返回指定对象所有自身属性（非继承属性）的描述对象。
const obj = { foo: 123, get bar() { return 'abc' }};Object.getOwnPropertyDescriptors(obj)// { foo:// { value: 123,// writable: true,// enumerable: true,// configurable: true },// bar:// { get: [Function: bar],// set: undefined,// enumerable: true,// configurable: true } }
上面代码中，Object.getOwnPropertyDescriptors方法返回一个对象，所有原对象的属性名都是该对象的属性名，对应的属性值就是该属性的描述对象。
该方法的实现非常容易。
function getOwnPropertyDescriptors(obj) { const result = {}; for (let key of Reflect.ownKeys(obj)) { result[key] = Object.getOwnPropertyDescriptor(obj, key); } return result;}
该方法的引入目的，主要是为了解决Object.assign()无法正确拷贝get属性和set属性的问题。
const source = { set foo(value) { console.log(value); }};const target1 = {};Object.assign(target1, source);Object.getOwnPropertyDescriptor(target1, 'foo')// { value: undefined,// writable: true,// enumerable: true,// configurable: true }
上面代码中，source对象的foo属性的值是一个赋值函数，Object.assign方法将这个属性拷贝给target1对象，结果该属性的值变成了undefined。这是因为Object.assign方法总是拷贝一个属性的值，而不会拷贝它背后的赋值方法或取值方法。
这时，Object.getOwnPropertyDescriptors方法配合Object.defineProperties方法，就可以实现正确拷贝。
const source = { set foo(value) { console.log(value); }};const target2 = {};Object.defineProperties(target2, Object.getOwnPropertyDescriptors(source));Object.getOwnPropertyDescriptor(target2, 'foo')// { get: undefined,// set: [Function: foo],// enumerable: true,// configurable: true }
上面代码中，将两个对象合并的逻辑提炼出来，就是下面这样。
const shallowMerge = (target, source) => Object.defineProperties( target, Object.getOwnPropertyDescriptors(source));
Object.getOwnPropertyDescriptors方法的另一个用处，是配合Object.create方法，将对象属性克隆到一个新对象。这属于浅拷贝。
const clone = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));// 或者const shallowClone = (obj) => Object.create( Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
上面代码会克隆对象obj。
另外，Object.getOwnPropertyDescriptors方法可以实现一个对象继承另一个对象。以前，继承另一个对象，常常写成下面这样。
const obj = { __proto__: prot, foo: 123,};
ES6 规定__proto__只有浏览器要部署，其他环境不用部署。如果去除__proto__，上面代码就要改成下面这样。
const obj = Object.create(prot);obj.foo = 123;// 或者const obj = Object.assign( Object.create(prot), { foo: 123, });
有了Object.getOwnPropertyDescriptors，我们就有了另一种写法。
const obj = Object.create( prot, Object.getOwnPropertyDescriptors({ foo: 123, }));
Object.getOwnPropertyDescriptors也可以用来实现 Mixin（混入）模式。
let mix = (object) => ({ with: (...mixins) => mixins.reduce( (c, mixin) => Object.create( c, Object.getOwnPropertyDescriptors(mixin) ), object)});// multiple mixins examplelet a = {a: 'a'};let b = {b: 'b'};let c = {c: 'c'};let d = mix(c).with(a, b);
上面代码中，对象a和b被混入了对象c。
出于完整性的考虑，Object.getOwnPropertyDescriptors进入标准以后，还会有Reflect.getOwnPropertyDescriptors方法。

12 Null传导运算符。
编程实务中，如果读取对象内部的某个属性，往往需要判断一下该对象是否存在。比如，要读取message.body.user.firstName，安全的写法是写成下面这样。
const firstName = (message && message.body && message.body.user && message.body.user.firstName) || 'default';
这样的层层判断非常麻烦，因此现在有一个提案，引入了“Null 传导运算符”（null propagation operator）?.，简化上面的写法。
const firstName = message?.body?.user?.firstName || 'default';
上面代码有三个?.运算符，只要其中一个返回null或undefined，就不再往下运算，而是返回undefined。
“Null 传导运算符”有四种用法。
obj?.prop // 读取对象属性
obj?.[expr] // 同上
func?.(...args) // 函数或对象方法的调用
new C?.(...args) // 构造函数的调用
传导运算符之所以写成obj?.prop，而不是obj?prop，是为了方便编译器能够区分三元运算符?:（比如obj?prop:123）。
下面是更多的例子。
// 如果 a 是 null 或 undefined, 返回 undefined// 否则返回 a.b.c().da?.b.c().d// 如果 a 是 null 或 undefined，下面的语句不产生任何效果// 否则执行 a.b = 42a?.b = 42// 如果 a 是 null 或 undefined，下面的语句不产生任何效果delete a?.b