ES6踩坑记录

这篇文章主要由于只是我的对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的判断条件