ES6

1、变量和常量

    let    const

        

let hello = "hello world";

    

    特点：1.1 没有声明提升了

              1.2 块级作用域; (大括号作用域) 

              1.3 TDZ 暂时性死区

        在变量声明前的所以区域；不能使用该变量的名称；一但使用就报错；

        1.4 for  和  let  的配合；

            

if(true){

    //console.log(a);

    let a = 10;

}

console.log(a);

 

for(var i = 0; i < 10 ; i++){

    (function (i){

    setTimeout (function(){

        console.log(i);

    })

})(i)

}

 

for(let i = 0; i < 10; i++){

    console.log(i);

    setTimeout(function(){

    console.log(i);

})

}

 

常量； 规范而言常量都有求纯大写变量名；

    

const HELLO = "hello world";

console.log(HEELO);

HELLO = 10;

 

常量一般用于引用类型；

模块化的时候通常使用常量去进行定义；

 

    2    解构赋值

                    批量赋值：

                           1、 数组赋值；

                            2、对象赋值；

                            3、...   （剩余运算符）

    part 1 

    

let [a,b,c,d,e,f,g] = [1,2,3,4,5,6,7];

console.log(a,b,c,d,e,f,g);

 

    剩余运算符

    

let [a,b,...g] = [1,2,3,4,5,9,7,8,];

console.log(a.b.g);

 

    part  2 

    

var a = window.alert;

a("hello world");

let {alert} = window;

let alert = window.alert;

 

var obj = {

    fn1 : function (){

        alert("i" m fn1)

    },

    fn2 : function(){

        alert("i" m fn2)

    },

    fn3 : function (){

        alert ("i" m fn2)

    }

}

 

var fn2 = obj.fn2;

var fn1 = obj.fn1;

var fn3 = obj.fn3;

 

let {fn1,fn2,fn3} = obj ;

console.log(fn1,fn2,fn3);

 

 

对象赋值中的扩展运算符；

    

let obj1 = {a : 1 ,b : 2};

let obj2 = {...obj1, c : 1}

console.log(obj2); 

 

字符串； 字符串模板

    1.支持换行；

        var hello = "hello world";

        var html = `

                                <ul>

                                        <li></li>

                                        <li>${hello}</li>

                                        <li></li>

                                        <li></li>

                                </ul>

                                `;

                        console.log(html);

 

    4.箭头函数：

        1、没有大括号的箭头函数；

            

        

let foo = a => a +1

console.log(foo(10))

 

        2、带有大括号的箭头函数

        

let foo = (a) => {

    return a + 1;

    }

console.log(foo(10))

 

    3、不同 ： 没有原型，不可以new 

    4、 不同 : 自动绑定this;

let foo = () = > {

 

}

var foo = function(){

 

}.bind(this);

 

             var obj = {

                  fn : function(){

                        setTimeout( ()=>{

                              console.log(this);

                        } , 1000)

 

                        // setTimeout(function(){

                        //       console.log(this);

                        // }.bind(this),1000)

                  }

            }

            obj.fn();

 

 

转载于:https://www.cnblogs.com/TianPeng2/p/9991736.html