2017-12-25es6解构赋值

2015年 ECMAscript 规范标准 js是实现
es6 IE10以下 不支持，需要装babel 编写复杂大型的
js是浏览器边解析边执行，解析器会优化代码
chrome V8引擎

一、 let

let var区别：
1.var存在变量提升 let不会
2.let 必须先定义再使用
3.暂时性的死区
4.作用域不同

var 函数作用域

function a(){
    if(true){
    var str = "1111"；  
    var  str = "2222"
  }
  console.log(str);
}
a();  //==>str "2222"

let 块级作用域

不能重复声明

function a(){
    if(true){
    let  str = "1111"；  
    let  str = "2222";
  console.log(str);
  }
  console.log(str);
}
a();  //==>str 不能被打印，并且会报错 

箭头函数

变量名（函数名） = 参数 => 函数体
var fa =v => v //箭头函数默认有一个返回return

//例
var fa = function(v) { 
  return v;
}
//如果不传参数
var fa =()=>'1234';
//如果传多个
var fa=(a1,a2,a3)=> a1 + a2 + a3;
fa(1,2,3)
//如果返回的是对象,如果不扩起来，会认为是函数体
let f = (n1,n2) => ({name:n1,age:n2})

暂时性的死区

var x = y, y = 2;
function a(){
    console.log(x,y);
};
a();  //==> undefind  2  

let x = y, y = 2;
function a(){
    console.log(x,y);
};
a();  //==> Uncaught ReferenceError: y is not defined

//函数内部重新声明

  let  i;  //此处错误
    if(true) {
        let  i ="aaa";  // 此处可行
    }
}

JS是浏览器边解析边执行，解析器会优化代码，谷歌 V8引擎； VAR是函数作用域 ，引擎扫描函数体会对VAR优化执行，会变量提升

二、const

const 声明一个只读的常量，常量的值不能改变
例： token
不能只申明不赋值，一旦声明变量，必须初始化值，不能改变

//错误示例
const str = '111';
str = '222'  //error
const str ;     //error
console.log(str) 

简单类型（字符串/布尔/数值）；
复合类型（数组，对象，指针不能变，里面值不受控制）

//在同一个作用域下
const obj = {};
    obj.name ='333';
    obj.action = function(){
        return this.name;  
    }
obj = {};
obj.action();   // =>error

三、变量的解构赋值

从数组和对象中提取值，对变量进行赋值，称为解构

数组的解构

按照次序来解构

var a=1,b=1,c=3;
//分开
var x = 1;
var y= 2;
var z = 3;
// 等同  模式匹配
let [x,y,z] = [1,2,3];
//取值
console.log(y)  //=> 2 ;
//按照位置匹配
let [a,b,c] = [1,,3];
console.log(c);   //=>3
//模式匹配 数组
let[x1,y2,z3] =[1,{'x':123},3];
//默认值
let [x1,y1 = '4',z1] =[1];
console.log(x1);   //1
console.log(z1);  //undefind
console.log(y1);  //'4'
//默认值替换undefined  null不会被替换
let [x,y,z] = [1,,null];
console.log(z)  //null

解构赋值允许指定默认值

  function f() {
       return 'aaa'
  };
let [x = f()] = [ ];
console.log(x);  //aaa;

对象的解构赋值

不是按次序，是按照属性名称匹配

let {x,y} ={y:'111',x:'222'}; 
console.log(y);  // 111;
let {x:aa,y} ={y:'111',x:'222'};
//x相当于匹配模式，aa才是变量名
console.log(x)  //=> x is not defined
console.log(aa) //=>222
let obj1 = {"x":"aaa","y":"bbb"};
let {x:c,y:a}  = obj1;
console.log(c)   //=>aaa
let {x = 1} = {x:'a'};
let {x = 1,y} = {x:'a'};
let {x :y = 3} = {x:'a'};
let {x :y = 3} = {x:undefined};  //y  3
let {x :y = 3} = {x:null};      //y null

三、字符串解构赋值

类似于数组对象

let[a,b,c,d] = 'hello'
console.log(a)  //=>"a"
console.log(d)  // =>"l"

四、函数参数的解构赋值

function fun([x,y]) {
  return x + y
}
fun([2,6]);    // 8
//没有传入参数
function fun([x,y]) {
  return x + y
}
fun([]);
//传参有默认值
function fun([x=4,y=0]) {
  return x + y
}
fun([2,6]);  //8
//常用
function num() {
  return [1,2,3]
}
let [a,b,c] = num()
console.log(a) //=1;
//转对象
function num(){
      let obj = {
        "x1" :"aa",
        "y1" : "bb"
      }
      return obj;
}
let {x1,y1} = num();
// let{x1:x1, y1:y1} =num();
console.log(x1);
//json
let obj = {
      "name":"aaa",
      "age":12,
      "friends":["a1","b1"],
      "members":{x:1,y:2}
 };
let {name,age,friends:ff,members} = obj;
//console.log(ff[1]);   //b1
console.log(members.y); //2