最近看阮一峰的ES6发现了个地方有点不懂，理解之后，特意记录下来。

let obj = {};
let arr = [];

({ foo: obj.prop, bar: arr[0] } = { foo: 123, bar: true });

obj // {prop:123}
arr // [true]

就是上面这块。
首先是外面这个括号，我们知道如果提前定义了一个变量，下面再来解构赋值就得加上括号而不是下面这样

	let a;
    let b;
    let [a, b] = [1, 2];
    // Uncaught SyntaxError: Identifier 'a' has already been declared 报错了

然后是里面的东西，我们读前面的内容之后

const node = {
  loc: {
    start: {
      line: 1,
      column: 5
    }
  }
};

let { loc, loc: { start }, loc: { start: { line }} } = node;
line // 1
loc  // Object {start: Object}
start // Object {line: 1, column: 5}

我们发现，给对象解构赋值的时候， ’ : ’ 冒号表示这个对象是个模式，而不是变量，只有 ’ = '等号或者不加等号才表示变量赋值，比如

    let a;
    let b;
    ({a, b} = {a: 10, b: 12})
    // ({a = 0, b} = {a: undefined, b: 12})

所以

({ foo: obj.prop, bar: arr[0] } = { foo: 123, bar: true });

这里面跟前面的例子一样，赋值是赋给 obj 的 prop 以及 arr 的第 0 项！
依照一一对应，所以 obj.prop 赋值 123， 而 arr[0] 赋值 true 就是这么来的。
阮一峰的es6地址：https://es6.ruanyifeng.com/#docs/destructuring
end

  var cc = {
    te1: 'ni',
    te2: 'nihao',
    te3: 'nihaoma',
    te4: ''
  };
  var { te1 } = cc;
  var { te1: bb } = cc;
  var { te2 = '', te3 = 'te3', te4 = 'te4', te5 = '21', te6 } = cc;
  console.log(te1); //ni
  console.log(bb); //ni
  console.log(te2); //nihao
  console.log(te3); //nihaoma
  console.log(te4); // ""
  console.log(te5); // ""
  console.log(te6); // undefined

函数解构

function testdata(
    contractStatus,
    option = {
      auditStatus: '',
      sendStatus: '',
      whenContractSubmitAudit: '',
      flowId: ''
    }
  ) {
    console.log(contractStatus)
    console.log(option)
    console.log(option.whenContractSubmitAudit)
    console.log(option.sendStatus)
    const { sendStatus = '', whenContractSubmitAudit = AUDIT_BEFORE_PURCHASE_SEND } = option;
}

testdata();

// undefined
// {
//   auditStatus: '',
//   sendStatus: '',
//   whenContractSubmitAudit: '',
//   flowId: ''
// }
// ""
// ""
console.log("--------------")

testdata(22,
    {
        auditStatus:"11",
        whenContractSubmitAudit:"33"
    }
);

// 22
// { auditStatus: '11', whenContractSubmitAudit: '33' }
// 33
// undefined

1.先用let声明一个变量：

let node ={
    type: 'inde',
    name: 'cao'
};

2.然后解构赋值

let {type,name} = node
{type, name}
// {type: "inde", name: "cao"}

3.对type，name重新赋值

{type, name} = {type: '1111', name: 'li'}
// {type: "1111", name: "li"}
type
//"1111"
type = 222
//222
type
//222

4.注意在 使用let {type,name} = node或者var {type,name} = node或者const时等号右边必须有值，也就是必需在声明时就做初始化（数组的解构赋值也是一样的）。
5. 但是如果在先声明了type或者name变量，在使用解构赋值就会报错

let node ={
    type: 'inde',
    name: 'cao'
},
    type = '111111',
    name = 'li';
type
//"111111"
let {type,name} = node
/* 报错
VM106:1 Uncaught SyntaxError: Identifier 'type' has already been declared
*    at <anonymous>:1:1
*(anonymous) @ VM106:1
*/
{type,name} = node
//报错 VM113:1 Uncaught SyntaxError: Unexpected token =

可以用表达式来赋值

({type,name} = node)
//{type: "inde", name: "cao"}

总结：
1.如果对已经使用let、var、const声明的变量，再使用对象的解构赋值时，需要使用表达式，不能直接使用{type,name} = node或者let {type,name} = node。
2.对使用对象解构赋值过的变量，可以再次直接只用对象解构赋值，不需要在使用let、var

let node ={
    type: 'inde',
    name: 'cao'
}
let {type,name} = node
{type, name}
//{type: "inde", name: "cao"}
{type, name} = {type: '1111', name: 'li'}
//{type: "1111", name: "li"}
type
//"1111"
type = 222
//222
```