经常使用的ES6新特征--解构赋值

let和const

由于var能够反复声明,而且没法限定修正,也没有块级作用域,在一些时刻不是很适宜,所以涌现了let和const

  • let:不能反复声明,能够修正,有块级作用域,合适for轮回等一些场景
  • const:不能反复声明,有块级作用域,不能够修正,比较合适做全局

变量的构造赋值

  • 数组的解构赋值

    let [a,b,c] = [1,2,3]
    let [d,[[e],f]] = [1,[[2],3]]//d=1,e=2,f=3
    let [x,y,...z] =['a'];//x="a",y=undefined,z=[]  构造不成功变量的值就为undefined

    不完全解构

    let [a,[b],c] = [1,[2,3],4];//a=1,b=2,c=4

    关于set构造,能够运用数组的解构数组

    let [x,y,z] = new Set(['a','b','c']);//a=a,y=b,z=c

    重要数据构造具有Iterator接口,都能够采纳数组情势的解构赋值,以下斐波那契数列的例子,应用generator函数

    function* fibs(){
        let a = 0 ;
        let b = 1;
        while(true){
            yield a;//应用yield返回中心值
            [a,b] = [b,a+b];
        }
    }
    let [first,second,third,fourth,fifth,sixth] = fibs();
    //first=0,second=1,third=1,fourth=2,fifth=3,sixth=5

    默认值

    解构赋值许可指定默认值,es6内部运用严厉相称运算符===推断一个位置是不是有值,所以只要当一个数组成员严厉即是undefined,默认值才会见效;默认值能够援用解构赋值的其他变量,但该变量必须已声明。

    let [x,y='b'] = ['a'];//x='a',y='b'
    let [x=1] = [undefined];//x=1
    let [x=1] = [null];//x=null
    let [x=1,y=x] = [2];//x=2,y=2   由于先把2解构赋给x,x把值赋给y,所以x,y都为2
    let [x=1,y=x]=[1,2];//x=1,y=2
  • 对象的解构赋值

    数组的解构和对象的解构有一个差别,数组的元素按序次分列,变量的取值由其位置决议;而对象的属性没有次数,变量必须和属性同名,才获得准确的值。

    let {foo:foo,bar:bar} = {foo:'qqq',bar:'www'}//foo=qqq,bar=www
    //嵌套解构
    let obj = {p:['hello',{y:'world'}]};
    let {p:[x,{y}]} = obj//x=hello,y=world  此时p作为形式不会被赋值
    let {p,p:[x,{y}]} = obj//p=['hello',{y:'world'}]  此时P作为变量赋值

    以下实例举行了三次解构,分别是对loc,start,line三个属性,然则末了解构赋值时,只要line是属性,start和loc都是形式,而不是变量

    const node = {
        loc:{
            start:{
                line:1,
                column:5
            }
        }
    };
    //第一个参数是对loc举行解构,获得loc = { start: { line: 1, column: 5 } }
    //第二个参数对start举行解构,获得start = { line: 1, column: 5 }
    //第三个参数对line举行解构,获得 line = 1
    let{ loc,loc:{start},loc:{start:{line}}} = node;
    console.log(loc);//{ start: { line: 1, column: 5 } }
    console.log(start);    //{ line: 1, column: 5 }
    console.log(line);//1

    嵌套赋值

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

    对象的默认值,和数组的默认值类似

    var {x:y=3}={x:5}//y=5
    var {x=3} = {x:undefined}//x=3
    var {x=3} = {x:null}//x=null
    var {foo} = {bar:'bz}//foo=undefined解构失利变量的值即是undefined

    一些毛病写法:

    let _tmp = {baz :'bz'};
    _tmp.foo.baz;//报错,由于foo已是undefined,再取子属性会报错
    let x;
    {x} = {x:1};//会报错,由于JavaScript引擎会把{x}诠释成代码块,只要防止将大括号写在行首,防止将其诠释成代码块,才防止报错
    let x;
    ({x} = {x:1});//准确写法
  • 字符串的解构赋值

    const [a,b,c,d,e] = 'hello'//a='h',b='e',....
    let {length:len}='hello'//len=5
  • 数值和布尔值的解构赋值

    解构赋值时,假如等号右侧是数值和布尔值,会先转为对象;而undefined和null没法转为对象,所以对它们解构赋值会报错

    let {toString:s} = 123;
    console.log(s === Number.prototype.toString);//true
    let {toString:s} = true;
    console.log(s === Boolean.prototype.toString);//true
    let { prop: x } = undefined; // TypeError
    let { prop: y } = null; // TypeError
  • 函数参数的解构赋值

    [[1, 2], [3, 4]].map(([a, b]) => a + b);//[3,7]

    函数参数的解构能够运用默认值,然则差别的写法会有区分,有以下两种状况,一种是为函数的参数指定默认值,一种是为变量指定默认值

    • 变量的默认值

      函数test的参数是一个对象,经由过程对对象的解构,获得参数x,y,解构失利,参数为默认值

    function test({x=0,y=0} ={}){
        return [x,y];
    }
    console.log(test({x:2,y:5}));//[2,5]
    console.log(test({x:2}));//[2,0]
    console.log(test({}));//[0,0]
    console.log(test());//[0,0]
    • 函数参数的默认值,下面是为函数的参数指定默认值
    function test({x,y} = {x:0,y:0}){
        return [x,y];
    }
    console.log(test({x:2,y:5}));//[2,5]
    console.log(test({x:2}));//[ 2, undefined ]
    console.log(test({}));//[ undefined, undefined ]
    console.log(test());[0,0]​                                  

变量解构赋值的用处

  • 交流变量的值
  • 从函数返回多个值
  • 函数参数的定义
  • 提取JSON数据
  • 函数参数的默认值
  • 遍历Map构造
  • 输入模块的指定要领
    原文作者:ZCJ爱笑的菇凉
    原文地址: https://segmentfault.com/a/1190000018061249
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞