解构 随笔

解构过程 ！= 变量申明
解构过程中， 等号右边的数据类型 不是iterator（迭代器,可遍历对象）会报错
对象也能解构

function t(x){  return x; }
var [a=t(1)]=[t()]
// a=1

var [a,b,c]=[1,2]
//c =undefined

var [a,,b]=[1,2,3,4,5]
// b=3


var [a,...b]=[1]
// a= 1  b=[]

var [a,...b]=[]
// a=undefined  b=[]

var [t,t,t]=[1,2,3]
// t=3

var [t=3,t=t] =[undefined,null]
// t=null

var [t=3,t,t=t]=[1,2]
// t=2

let [t,t]=[1,2]
//error 

var [a=b,b=4]=[]
// a=undefined b=4

let [a=b,b=4]=[]
//error  let 不存在变量提升

let {t=1}={}
// t=1

let {t:x}={t:1}
//t=1

var {0:t}=[1]
// t=1

var {a:[x]}={a:[1]}
//error    解构时a:[x] 中的a 表示模式
var {a,a:[x]}={a:[1]}
// a=[1] x=1   

var t = {tt:1};
var { a: t.tt} = { a: 123}
// error
var t = {tt:1};
({ a: t.tt} = { a: 123})
// t.tt =123
// ---------------------------------------------没懂

var {t:x[0]}={t:1}
//error  父解构不存在

目标结果得到 x=1

var {t:x}={t:{x:1}}
// x={x:1}
var {t: x :x}={t:{x:1}}
// error
var {t:{x}}={t:{x:1}}
// x=1

解构过程中的属性获取

 var {keys:t}=Object.keys
    // t === Object.keys

解构过程中的类型转换

 var {slice:t}='123'
    //   '123' => String('123') 
    // 注意 这里   t === String.prototype.slice

数组转对象

  var {[1+1]:t}=[1,2,3]
    //t=3
    var {0:t}=[1,2,3]
    //t=1
    var {(1+1):t}=[1,2,3]
    //error 解构中圆括号的使用
    
let t;
{t} = {x: 1};
//如果要将一个已经声明的变量用于解构赋值会报错 ，JavaScript 引擎会将{x}理解成一个代码块
let x;
({x} = {x: 1});
// x=1 success

怪异写法：

  []=[] // success
    {}={}//success
    []={} ([]={})  // error
    {}=[] //error 
    ({}=[]) //success
    []='  ' //success
    '  '=[]    ('  '=[])  //error

使用圆括号正确的情况（来自es6书本）：

[(b)] = [3]; // 正确
({ p: (d) } = {}); // 正确
[(parseInt.prop)] = [3]; // 正确

使用圆括号错误的情况（来自es6书本）：

let [(a)] = [1];
let {x: (c)} = {};
let ({x: c}) = {};
let {(x: c)} = {};
let {(x): c} = {};

let { o: ({ p: p }) } = { o: { p: 2 } };