这篇文章主要因为只是个人对ES6的不完整的理解，写的不是很生动，如果有比较了解的欢迎纠错。

1.箭头函数
省略 function 省略return；
原来的

        function (){
            retrun...
        }
        变成
        () = >

2.const 和 let

const过程大概为检测 命名是否内存中存在? 报错 ：命名 ;
命名过程中，如果函数出错，命名依旧占过去，不能再重新给函数定义这个命名。

 var x;
 const x = () => {...}//报错，命名已经存在
 const y = () => {console.log(1)//报错，miss },定义函数失败
 const y = () => {console.log(1)}//报错，命名已存在

let作用于块级作用域，从我肤浅的理解角度，就类似个闭包的参数。所以没法再同一作用域用let定义同一个参数。闭包参数有个特色，对外为变量，为内为常量。

   
   let x = 1;
   let x = 2;//报错，x已经被声明。
   function test(){let x = 3};//不报错
   
   for(var i = 0;i < 5;i++){ 
        setTimeout(() => {console.log(i)},1000)
   }// 5 5 5 5 5
   
   for(let i = 0;i < 5;i++){ 
        setTimeout(() => {console.log(i)},1000)
   }// 0 1 2 3 4 
   
   这实际等于
    var n = (t) =>{setTimeout(() => {console.log(t)},1000)}
    for(var i = 0;i < 5;i++){
    n(i);
    }

3.promises
异步处理功能
定义一个函数为new Promise(),Promises里面有俩个参数对象，resolve //成功,reject //失败，这俩个参数写在函数的最后面，表示这个函数是不是执行成功了。
resolve和reject可以带入自己的参数。
.then()可以无限链下去。我个人觉得这个可以封装一个方法。

var con1 = new Promise(function(resolve,reject){
   setTimeout(() => {console.log(1);true?resolve('成功'):reject('失败')},1000)
})

var con2 = (t) => {setTimeout(() => {console.log(t)},1000)};

con1.then((resolve的参数) => {con2(resolve的参数)},(reject的参数) => {con2(reject的参数)})

4.class
class应该是涉及到了原型链，原型链就是一个函数的原型函数，区别于构造函数。主要用于继承。
我理解的继承的意义就是提高代码复用率。

  class test1{
   testOne(){console.log('this is test1.testOne')}
   }
   
   class test2 extends test1{
   testTwo(){console.log('this is test2.testTwo')}
   }
   
   var test3 = new test2();
   test3.testOne();//this is test1.testOne
   test3.testTwo();//this is test1.testTwo
   

5.数组合并rest
rest的写法就是…

     var testRest = (...x) => {console.log(x)};
     tesrRest(1,2,3)//[1,2,3]   
     const a = [1,2,3];
     const b = [4,5,6];
     const c = [...a,...b];//[1,2,3,4,5,6]

6.遍历forEach

        c.forEach(function(data){
        console.log(data)
        })//1 2 3 4 5 6 

7.默认值

        var z = undefined;
        var x1 = z||'默认值z';//默认值z
        var y = 'y';
        var x2 = y||'默认值y';//y
        var q = false;
        var x3 = q||'默认值q';//默认值q
        var w = null;
        var x4 = w||'默认值w';//默认值w
        var e = '';
        var x5 = e||'默认值e';//默认值e

我觉得这里面最没怎么踩懂的就是class 因为原型链还是没有能完全弄懂 踩得最忐忑的就是 promise 因为这里面的格式太局限了，而且网上找的解释很多不解释reslove和reject的判断条件