1.小程序可以直接编些ES6，可以直接转换
2，node支持ES6非常全
3，不太适合html和js混合写，因为兼容性不太好
**let 块级作用域 **
1.不允许重复定义
2.在作用域外访问不了let定义的变量
3,类似于封闭空间，for循环i 外面访问不了
4，就是一个匿名函数立即调用
** const ' ' **
1，定义常量，一旦赋值无法修改
2，const必须声明的时候赋初始值，因为后面不允许再次定义
3，不能重复声明，和let一样
** 字符串连接, `` **
var a="我的"
var b="hannah"
console.log( ${a}名字叫${} )
xxxxx$(变量名)xxxxx
有一个点 包住，才能使用${a}
**模板字符串(变量名)** 1，需要写在点里面，可以使用变量用(变量名)
2，{}，大括号内部可以放任意js表达式，也可以运算，甚至还可以调用函数${fn()}
模板编译
xxxxxxxxxxxxxxxx（待完工）xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx（）
很重要的
**结构赋值 **
1.左边和右边的机构是一样的
var [a,b,c]=[12,5,101];//顺序要相对
console.log(a,b,c)//12,5,101
和json配合
var {a,b,c}={a:12,b:5,c:101}//和顺序无关
console.log(a)//12
var [a,[b,c],d]=[12,[1,2],5]//结构一定要一样，格式一定要是一样的
var jsons={"statuses":[{b:5,c:3,a:9}],"sta":[{b:5,c:3,a:9}]}
var {statuses,sta}=jsons
比较深层次的json数据
var jsons={"statuses":[{b:5,c:3,a:9}],"sta":[{b:5,c:3,a:9}]}
var {statuses,sta}=jsons
console.log(sta);
var [{a,b,c}]=sta;
console.log(a)
函数默认值
function getPost(){
return {left :100,stop:1000}
}
var {left,stop}=getPost();
console.log(left,stop)//100,1000
结构赋值给默认值
var{time=12,id=0}={};
console.log(time)//12
**复制数组Array.from [...args] **
Array.from
普通数组复制，如果想复制出一个独立可删减的数组需要for循环去做现在：
var arr=[1,2,3];
var arr2=Array.from(arr)
[...args]
var arr=[1,2,3];
var arr2=[...arr];
函数中的超引用
function show(...args){
console.log(args);//是一个独立的数组，可以增删改查
}
show（1,2,3,4）；
** 循环 for of **
之前es5 中for 或者for in
现在是 for of
for in 遍历的是索引 1,2,3
for of 遍历的索引指向的值！
for in 循环主要就是为了循环json
for of 只要就是为了循环 Map。
for of 可以循环数据，但是不能循环json！
Map 对象不可以使用for in 循环
Map 对象：初始化是一个二维数组。
Map就是为了和for of 循环相结合使用
var map =new Map（）；
map.set("a","apple")//设置值
var map=new Map([["name", "张三"], ["title", "Author"]]);//也可以这样设置值
map.get("a");//获取a 的值 “apple”
map.delete("a")//删除值！
Map配合for of 循环操作
全部key和value
var map=new Map([["name", "张三"], ["title", "李四"]]);
for(var n of map){
console.log(n);//["name","张三"]["title","Author"]
}
只出现单个kay或者单个value写法如下
for(var [key,val] of map){
console.log(key);//name，title
console.log(b);//张三，李四
console.log(b,a);//张三 name,李四 title
}
只个循环key 或者value
for(var key of map.keys()){
console.log(key)//name title
}
for(var val of map.value()){
console.log(val)//张三，李四
}
for of 循环数组
循环值，默认循环值
var arr=[1,2,3];
for(var name of arr){
console.log(name)//循环是值！
}
循环全部arr.entries()
for(var name of arr.entries()){
console.log(name)//循环是值！
}
循环索引 arr.keys()
for(var name of arr.keys()){
console.log(name)//循环是值！
}
** 箭头函数=> **
使用箭头函数的注意点：
1，函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象（那里定义，或者那里调用）
2，不可当做构造函数，也就是不能使用new命令。
3，不能使用argument对象，可以使用reset（...arg）代替
4，不可以使用yield命令。
5,函数是按值传递的，但是普通函数，传递obj对象，如果在函数内修改参数的值，会影响外面obj对象，如果从新赋值一个实例就不会影响外貌。箭头函数中的reset...不同。
**面向对象**
ES5
function Person(name,age){ //又是类又是构造函数
this.name=name;
this.age=age;
};
Person.prototype.showName=function(){
return this.name;
};
var P=new Person("hanna",18);
console.log(P.name);
console.log(P.showName())
ES6
1，参数是可以是默认值的。
class Person{//真正的类
constructor（name,age）{//构造函数
this.name=name;//构造函数的属性
this.age=age;
},
showName （）{//构造函数的方法
return this.name
}
}
var p1=new Person("aaa",111);
alert(p1.name);
**面向对象的继承**
ES5
function Person(name,age){ //父类
this.name=name;
this.age=age;
};
function wor(name,age){//子类
Person.call(this,name,age);//在子类的执行环境中执行父类的方法和属性
};
var aa=new wor("11",11);
console.log(aa.showName());
ES6
class Worker extends Person{//直接继承了
/*constructor(...args){//如果子类写了构造方法，那么会覆盖父类的属性
super(...args)
this.name="111111111111";
}; */
};
var o=new Worker("11",11);//new出来子类实例
console.log(o.showName());//直接子类实例调用，就可以调用到父类的方法和属性了
** 模块化 **
ES6自带的模块化。
如何定义模块化
如果使用
如果引用
区别1，common 输出的是值得拷贝，ES6 是值得引用，
Common是运行时加载，ES6是编译是输出接口。
Common是加载时执行，es6是先加载，等渲染结束在执行
Common循环加载有可能返回的是执行一部分的数据不是最终全部的数据，
Es6引用的循环加载因为都是只加载一次，所以有能因为发现引用，就去加载引用的模块，导致用到的时候为null。
Es6的模块加载和defer，一样，都是先异步加载等到页面渲染完成在执行脚本。
Es6 模块是并发性不是继发性，cmd和amd，区别也是继发和并发，commonjS是并发性。
Export defauit class{
。。。。
}
Import myclass from‘myclass’；
Let myclass =new myclass()
** **
** **
** **
** **
** **
** **
** **
** **
** **
** *`