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构造
• 输入模块的指定要领