es6新语法

1.let 块级作用域

{    //块级作用域

}

function f(){     //局部作用域

}

var声明变量会存在变量提升，会将变量提升到当前作用域的最顶端，而复制操作还会处在原处。

函数声明也会提升

f('superman');

function f(name){

        console.log(name);        //superman

}

函数表达式不会提升

let和const 都不能重复声明，都有块级作用限制

const 声明常量，一旦定义，不能修改，声明时必须赋值

let和var声明变量，可以修改，声明时可以不用赋值

2.对象     

var obj={

        name, 属性名称：属性值 如果两者相等可以省略

        //方法

        say(){}

}

3.结构赋值 是对赋值运算符（=）的扩展

var obj={

        name='张三',

        age:18

}

var {name,age}=obj;

设置默认值，如果有值，会把默认值替换掉

var {name='李四',age=20}=obj;

改名

var { name:studentName, age:studentAge }=obj;

数组结构赋值

var [a,b]=[10,20]                   //10 20

var [a, ,b]=[10,20,30]          //10 30

var [a,b]=[10]          //10 undefined

var [a=10]=[]          //10 

var [a,b,c]='asd'        //a s d

var [a,...b]=[1,2,3,4,5]        //1 [2,3,4,5]

4.展开运算符

数组：

var arr =[1,2,3];

var arr2 =[4,5,6];

console.log(...arr);        //1 2 3

console.log([...arr,...arr2]);        //[1,2,3,4,5,6]

console.log(...[...arr,...arr2]);        //1 2 3 4 5 6

对象：

var obj={name='张三',age:18};

var obj2={sex:'男',...obj};                              //深拷贝 

obj2.name='李四'；

console.log(obj,obj2);   //obj{name='张三',age:18}    obj2{name='李四',age:18,sex:'男'}

深拷贝另一种方式：   assign

var obj3={name='张三'};

var obj4={sex:'男'};   

var obj5=Object.assign({},obj3,obj4) ;        第一个参数是目标对象，后面的参数都是源对象,返回目标对象

5.函数默认值

function f(a=10){

        console.log(a+1);

}

6.模板字符串

1.插值  2.换行(字符串换行会报错)        使用上引号``

var a=10

`http://baidu.com?a=${a}&

b=${10}`

7.rest剩余参数    表示不确定参数有多少

function f(a,...b){

        console.log(a,b);            //1 [2,3,4,5,6]

}

f(1,2,3,4,5,6)

8.箭头函数

()=>{}

1.如果只有一个参数可以省略（）   item=>{}

2.当函数里面只有一句话时且return的时候，{}和return都可以省略

3.箭头函数简写时，返回的对象需要（）包裹

4.没有形参和多个形参的时候，需要添加（）

5.多行必须使用{}包裹

箭头函数没有自己的this,不能使用call,apply,bind方法改变this，this与上下文保持一致

9.set对象        储存的值时唯一的

var s=new Set([1,2,3,3,2]);     //(1,2,3)

s.sdd(4);        //如果添加的值存在，无效

s.delete(1) ;     //删除

s.has(4);        //是否存在

s.clear();        //删除所有

数组去重

var s=new Set([1,2,3,3,2]); 

console.log([...s]);        //[1,2,3]

字符串去重

var s=new Set('asdas'); 

console.log([...s].join(''));        //'asd'

10.try...catch和throw

try{

        console.log(10/0);

}catch(error){

        console.log(error);

}finally{

        console.log('无论是否出错，finally总会执行');

}

function checkAge(age){

        if(age>100){throw new Error('太大')}

}

11.Symbol     

es6引入一个新的基本数据类型Symbol，表示独一无二的值，最大用法定义唯一值的。

var sym1=new Symbol('hello');

var sym2=new Symbol('hello');

console.log(sym1==sym2);        //flase

12.类

class Person{

        constructor(name,age){        //私有属性和方法

                this.name=name;

                this.age=age;

        }

        say(){console.log('公共的')}

}

var p =new Person('李四',11);

13.继承

class Student extends Person{

         constructor(name,age,className){

                super(name,age);

                this.className=className;

        }

}

var p =new Person('李四',11,'3班');

14.Proxy

var obj={txt:0}

var p=new Proxy(obj,{

        get(target,key){

                return target[key];

        }

        set(target,key,value){

                target[key]=value;

        }

})

es5中使用

var obj={};

var num=10;

Object.defineProperty{obj,'age',{

        get:function(){

                return num;

        }

        set:function(value){

                 num=value;

        }

}}

15.promise

var p=new Promise(function(resolve,reject){

        setTimeout(()=>{

                resolve(6666);        //成功解决

        },1000)

})

三种状态        resolve 成功解决        reject 拒绝        pendding请求中

p.then((res)=>{

        console.log(res);        //6666

}).catch(err=>{

        console.log(err);       

}).finally(()=>{

         console.log('无论成功失败都会执行');

})

1.每次.then执行完成之后返回一个Promise。

2.上层.then返回值，会被下一层接收到。

3.解决了传统回调函数层层嵌套问题。

4.上一层返回新的Promise,则下一层then指定的是新的Promise的回调。

Promise.all() 当所有的promise执行结束时

Promise.race() 只要有一个异步执行完成，那就结束

function setTime(t){

        return new  Promise(function(resolve,reject){

                setTimeout(()=>{

                        resolve(6666);        //成功解决

                },t)

        })

}

Promise.all([setTime(500),setTime(800),setTime(1000)]);        //1000ms

Promise.race([setTime(500),setTime(800),setTime(1000)]);        //500ms

16.async    await   异步=>同步

;(async function(){

        var res=await setTime(1000);

})()