es6基本语法

const与let不能提升变量
直接看例子

let a=40;//let可以重新赋值
console.log(a);
a=66
const b=44;
console.log(b);

let作用域只限于当前代码块

{
    let a=38
}
console.log(a);//所以会报错
{
    let a=33
    console.log(a);//33
}
在作用域里的变量也不会被提升
{
   console.log(a);//报错
    let a=22;//
    let a='chdbhd';

}
{
    let a=22;//报错
    let a='chdbhd';

}

以前我们使用的var 会考虑到‘闭包’
例如

var lis=document.querySelectorAll('ul li');

for(var i=0;i<lis.length;i++){
(
    function(i){
        lis[i].onclick=function(){
            console.log(i);//这样会点击到每一项
        }
    }
)(i)
}

然而es6中的let直接跳过闭包，也就是直接跳过当前函数作用域。

let lis=document.querySelectorAll('ul li');
//直接跳过作用域

for(let i=0;i<lis.length;i++){
lis[i].onclick=function(){
   console.log(i); //点击了每一项
   
}
}

从而看出let比var更高级些
但是相对于对象来说的话，它可以在当前作用域的外面打印到；在对象里面

{
    console.log(obj.name); //报错

    const obj = {
        name:"李三"
     }

    console.log(obj.name);//李三
    
    obj.name = "远方";
}

这里可以看出const作为对象时也不能变量提升

{

    const obj = {
        name:"李三"
     }
    console.log(obj.name); //李三

    console.log(obj.name);//李三，访问不到下面的
    
    obj.name = "远方";
    console.log(obj.name);//远方
}

结构赋值
在es5中我们进行相关赋值的时候，
只能一个一个进行赋值，使用逗号的进行赋值也只是最右边的赋值才生效。
在es6中出现了赋值解构，分两种情况一个是数组解构，一个是对象解构赋值。

用于对象的拼接

let obj1={
name:'',
age:56
}
let obj2={
    name:'vdgcv',
    sex:11
}
let obj={}
Object.assign(obj,obj1,obj2);
console.log(obj);//{name: "vdgcv", age: 56, sex: 11}

//数组的扩展
Array.from
Array.of

let lis = document.querySelectorAll("li")
   console.log(Array.isArray(lis));  //false
    Array.from(list);  //将非数组lis转为数组
    console.log(Array.isArray(Array.from(lis))); //true检测数组
    console.log(Array.from(lis)); [li, li, li, li, li]
   console.log(Array.of(lis));

总结下var const let的区别：

1，var 声明的变量属于函数组作用域，let，const声明的变量属于块级作用域，
2，var存在变量提升现象，而let和const没有；
3，var变量可以重复声明，而在同一个作用域，let const变量都不能重复声明，const变量不能修改，

结构赋值
ES6允许按照一定的模式从数组和对象中提取值，对变量进行赋值，这被称为解构。
（1）、基本用法
以前的定义方法let name = "李四";let age = 20;let sex = "女"
新的定义方法let [name,age,sex] = ["李四",20,"女"]; //console.log(name)-->李四
(2)、对象的解构赋值
前面的key值和后面的key值相对应的

  let {name,age,friends} = {name:"zhangsan",age:12,friends:["lulu","女"]};
  console.log(name); //zhangsan

(3)、嵌套数组的解构赋值

//只要一一对应就可以let [a1,[a2,a3,[a4,a5]]] = [1,[2,3,[4,5]]];
console.log(a1,a2,a3,a4,a5);  //1，2，3，4，5

4）、字符串的解构赋值

let [a,b,c,d,e] = "我是中国人";console.log(a);   //我console.log(b);   //是console.log(c);   //中console.log(d);   //国console.log(e);   //人

（5）、空缺变量

let [a,b,,e]=['a','b',[1,2],4]

(6)、多余变量

let [a,b,,e,f]=['a','b',[3,4],5]
//注意：因为字符串有构造器，所以可以解析出来。

数据集合: set
1 ，特点
① 类似于数组，但没有重复的元素（唯一的）;
② 开发中用于去除重复数据;
③ key和value都是相等的;

let set = new Set(['zhangsan','zhangsan','lisi','wangwu']);console.log(set);  // zhangsan ,lisi ,wangwu

2 ，一个属性
let set = new Set(['zhangsan','zhangsan','lisi','wangwu']);console.log(set.size); // 3
3，四个方法
① add方法：

vlet set = new Set(["zhangsan","lisi"]);
console.log(set); // {"zhangsan", "lisi"}set.add("wangwu");
console.log(set); // {"zhangsan", "lisi", "wangwu"}

②delete方法：

let set = new Set(["zhangsan","lisi"]);//直接将删除的值传进去即可set.delete("lisi");
console.log(set); //{"zhangsan"}

③has方法：

let set = new Set(["zhangsan","lisi"]);
console.log(set.has("lisi"));  //true

④clear方法：

let set = new Set(["zhangsan","lisi"]);set.clear(); // 此时set为空了

_`~`数据集合：map
(1)、特点
① 类似于对象，本质上是键值对的集合;
② "键"不局限于字符串，各种类型的值（包括对象）都可以当做键;
③ 对象"字符串——值",Map"值——值",是一种更完善的hash结构实现;

  //创建map
  let obj1 = {a:1}, obj2 ={b:2};
  const map = new Map([
    ['name','张雪'],
    ["age",21],
    ["sex",'男'],
    [obj1,"haha"],
    [obj2,'wowo']
  ]);
  console.log(map);   //{"name" => "张雪", "age" => 21, "sex" => "男", Object => "haha",Object => "wowo"}

(2)、一个属性

const map = new Map([
    ['name','张雪'],
    ["age",21],
    ["age",21],
    ["sex",'男']
]);console.log(map.size); //3