ES 6

1. var let 和const：都是用来声明变量的。相比而言let和const都有代码块的概念，只有在代码块内有效，const和c中的define差不多，只要声明不可修改。并且在声明时必须初始化。测试代码：

   //var  
   var name1="test1out";
   if(1){
   	var name1="test1";
   	alert(name1);//test1
   }
   alert(name1);//test1
   //let
   let name2="test2out";
   if(1){
   	let name2="test2";
   	alert(name2);//test2
   }
   alert(name2);//test2out
   //var  
   var test3=[];
   for(var i=0;i<10;i++){
   	test3[i]=function(){
   		alert(i);
   	}
   }
   test3[6]();//10
   //let
   var test4=[];
   for(let j=0;j<10;j++){
   	test4[j]=function(){
   		alert(j);
   	}
   }
   test4[6]();//6
   

   　　

2. 解构赋值：

   let dog = "dog";
   let cat = "cat";
   let animal={dog,cat};
   console.log(animal);//{dog:"dog",cat:"cat"}
   
   //or
   let dog = {
       type: "animal",
       many: 2
   }
   let{type,many}=dog;
   console.log(type,many);//animal 2

3. 从函数返回多个值：

     //返回array
     function returnArray(){
         return [1,2,3]
     }
     let [a,b,c]=returnArray();
     console.log(a,b,c)//1,2,3
     //返回object
     function returnObject(){
         return {
           d:1,
            e:2,
            f:3
        }
    }
    let {d,e,f}=returnObject();
    console.log(d,e,f)//1,2,3
    
    //json
    let jsonData={
       id:42,
        status:true,
        data:[12,"成功"]
    }
   let {id,status,data}=jsonData;
    console.log(id,status,data[1]);
   //输入模块的制定方法
   const {modela,modelb}=require("map");

4. es6允许直接写入变量和函数，例如：

   const a="b";
   const c={a}; //{a:"b"}

   const o={
       method(){
           return true;
       }
   }
   //相当于
   const o={
       method:function(){
           return true;
       }
   }

5. Object.assign()方法：用于对象合并，同名时后面的会覆盖掉前面的。
6. 函数扩展：

   //默认值
   //ES6之前,需要处理才能用
   function log(a, b) {
       if(b === "undefined") {
           b = flag;
       }
       console.log(a, b)
       log(c); //c world
   }
   //ES6
   function log(a, b='flag') {
       console.log(a, b)
       log(c); //c world
   }
   //函数
   var f=v=>v;
   //相当于
   var f=function(v){
       return v;
   }
   //不需要传参
   var f=()=>{ var a=5;return a};
   //对象报错问题 ,要用两个大括号，外面一个代表的是代码块
   let f()=>{{id:"a",name:"luo"}};
   //this问题,因为当我们使用箭头函数时，函数体体内的 this对象，为从外部继承的this
   class Animal{
       constructor(){
           this.type="animal"
       }
       says(say){
           setTimeout(()=>{
               console.log(this.type+"says"+say)
           },1000)
       }
   }
   var animals=new Animal();
   animal.says("hi")//animal says hi

7. 模板字符串或变量：他的输出模板和模板引擎差不多，反引号（·）标识，可用于当做普通字符串或定义多行字符串或在字符串中嵌入变量。
8. 可用trim方法销毁换行
9. class（类）的基本语法：

   //javas中，生成实例对象的传统方法是通过构造函数：
   function Point(x,y){
       this.x=x;
       this.y=y;
       
   }
   Point.prototype.toString=function(){
       return '('+this.x+','+this.y+')';
   }
   var p=new Point(1,2);
   console.log(p);

   这种方式对于熟悉c和c++的人们来说会带来一定的困惑因此ES6引入Class的概念，可以用来定义类：

   class Point {
       constructor(x, y) {
           this.x = x;
           this.y = y;
       }
       toString() {
           return '(' + this.x + ',' + this.y + ')';
       }
   }
   
   var p = new Point(1, 2);
   console.log(p);//{x:1,y:2}

   class Point{ }
       class ColorPoint extends Point{
           constructor(x,y,color){
               super(x,y);
               this.color=color;
           }
           toString(){
               return this.color+' '+super.toString();
           }
       }