变量的结构赋值

数组的结构赋值

{
    let [a,b,c]=[1,3,4];
    console.log(a+'+'+b+'+'+c);// 1+3+4

    let [one,...two]=[3,4,5,6,7];
    console.log(one+":"+two);//3:4,5,6,7

    let [foo]=[];
    console.log(foo)//undefined
}

上面的这种写法属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值，如果变量找不到对应的属性，就会报undefined

数组结构赋值的默认值

{
    let [q,e=2]=[1];
    console.log(q+'+'+e);//1+2
    let [r,t=3]=[2,null];
    console.log(r+'+'+t);//2+null
}

ES6 内部使用严格相等运算符（===），判断一个位置是否有值。所以，如果一个数组成员不严格等于undefined，默认值是不会生效的。例如上面的null不等于undefined

对象的结构赋值

{
     let {t, y}={t: 3, y: 5};
     console.log(t + '+' + y);//3+5
}
{
     let {t:t,y:y}={t:3,y:5}
     console.log(t+'+'+y);//3+5
}

上面的例子第二个很好的解释了对象的赋值，第一个是简写的味道，也就是说当属性跟变量相等时，可以写成第一种简写的方式

let {t:x}={t:5};
console.log(x);//5

对象的解构赋值的内部机制，是先找到同名属性，然后再赋给对应的变量。真正被赋值的是后者，而不是前者,上面的例子解释了这一说法

下面我们看一个比较常用的对象结构赋值，我们平常做ajax交互时，后台传给前端的一个对象，我们要用这个对象其中的一个属性值，往往都是var很多变量，现在对象结构赋值攻克了这一难题

let obj={
     p:[
         1,2,3,{
            name:'zhangsan',
            arr:[
               3,4,5
            ]
         }
    ]
};
//假如我们要拿p属性对应的属性值，我们就可以这样来写
{
   let {p}=obj;
   console.log(p);//[1, 2, 3, Object]
}

//现在有人说了，你这这么麻烦，我直接var一个变量var p=obj.p不就完事了吗？还那么费劲干嘛，OK，现在我们来点深度的

let {p:[f,g,h,j]}=obj;
console.log(f+'+'+j);//1+[object Object]

//see，我们取到了数组的1,2,3，也可以取到arr，方便多了，我们再看一个例子

{
    let {p:[f,g,h,{name,arr:[l,o,m]}]}=obj; //注意，这时p是模式，不是变量，因此不会被赋值。
    console.log(name+'+'+l);//zhangsan+3
    //我们现在也可以拿到arr里面的东西了，注意，这时候的p和arr是模式，不是变量，不会被赋值，一定要切记
}

对象结构赋值的默认值

{
    let {name,age=15}={name:'zhangsan'};
    console.log(age);//15
}
{
    let {name:names='zhangsan',age=15}={name:null,age:undefined}
    console.log(names);//null
    console.log(age);//15
}

以上的两个例子说明了，默认值生效的条件是，对象的属性值严格等于undefined

字符串的结构赋值

{
     //字符串被转换成了一个类似数组的对象。
     const [a,b,c,d,e]='hello';
     console.log(a);//h
     console.log(c);//l
     console.log(e);//o

     //类似数组的对象都有一个length属性，因此还可以对这个属性解构赋值。
     const {length:len}='zhangsan';
     console.log(len);//8
}

函数的结构赋值

{
     function add([x, y]){
         return x + y;
     }
     console.log(add([1, 2])); // 3
}

函数add的参数表面上是一个数组，但在传入参数的那一刻，数组参数就被解构成变量x和y。对于函数内部的代码来说，它们能感受到的参数就是x和y。

函数参数的默认值

{
    function calc([x=0,y=0]=[]){
       return x+y;
    }
    console.log(calc());//0
    console.log(calc([]));//0
    console.log(calc([1]));//1
    console.log(calc([1,4]));//5

    function move({x = 0, y = 0} = {}) {
        return [x, y];
    }
    console.log(move({x: 3, y: 8})); // [3, 8]
    console.log(move({x: 3})); // [3, 0]
    console.log(move({})); // [0, 0]
    console.log(move()); // [0, 0]
}

函数calc的参数是一个数组，对象函数move的参数是一个对象，通过对这个对象进行解构，得到变量x和y的值。如果解构失败，x和y等于默认值。

</br>

小小的总结一下，个人感觉数组、对象、函数参数的结构赋值在实际工作当中还是有用的，比如说数组，当变量较多时，可以用数组的结构赋值，对象的结构赋值在ajax交互时也是蛮有用的，函数的参数结构赋值，个人感觉参数默认的默认值是有用的，当传入参数的情况下和不传入参数的情况下，这种写法还是比较简略的，以上就是变量的结构赋值，希望能给大家带来帮助，THX~

</br>
还是老惯例：
如果希望学习更详细的资料，请狠狠的点击这里~
</br>
</br>
</br>