关键字

是否存在

变量提升

是否存在

暂时性死区

是否允许

重复声明

是否允许

重新赋值

是否允许

只声明不赋值

var

存在

不存在

允许

允许

允许

let

不存在

存在

不允许

允许

允许

const

不存在

存在

不允许

不允许

不允许

//声明                                         

var str =``;

//嵌入变量

var str = `` ;                                                         

语法:

let {属性名1,属性名2,...} = 对象;

例如:

    let {username,password} = user;

语法:                                                

let [变量1,变量2,...] = 数组;

例如:

let [x,y,z] = [1,2,3];

语法:     

function 函数名 (参数1,参数2 = 默认值){

    //函数体

}                                          

例如:

function show(a,b = " love you"){

    console.info(a + b);       //I love you

}

show("I");

语法:                                                         

对象 = {

属性1 : 属性值1,

属性2,           //当属性名与属性值一致时,可以 写一个.

                            //需要注意:    不能使用双引号                      

函数名 : function( 参数列表){

        //函数体

}

}

例如:

var username = `jack`;

var password = `123`;

var user = {

    username ,

    password,    //    ''password'' =password

    show:function(){

            //函数体

}

}

箭头函数：用于定义匿名函数的一种简洁写法;

语法:                                                                                        

(参数列表) => {

        //函数体

}

//提示1: 当参数列表只有一个参数时,小括号可以省略

//提示2:当函数体只有一条语句时,花括号可以省略; 如果是return语句时,return必须省略         

      例如:

//提示1: 当参数列表只有一个参数时,小括号可以省略

    a =>{

   var sum =0;

        sum +=a;

    console.info(sum);

    }

//提示2:当函数体只有一条语句时,花括号可以省略; 如果是return语句时,return必须省略

var fn3_1 = (a,b) => {                              //普通语句

    console.info("普通语句");

}

var fn3_2 = (a,b) => {

    return a+b;                                      //return语句

}

var fn3_3 = (a,b) => console.info("普通语句");   //普通语句的省略写法

var fn3_4 = (a,b) => a+b;                          //return语句的省略写法，必须省略return

 *     JavaScript的对象（Object），本质上是键值对的集合（Hash结构），但是传统上

        只能用字符串当作键。这给它的使用带来了很大的限制;

*      ES6提供了Map数据结构。它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串

语法:

//创建map                                                                                                         

Var map = new   Map();

//设置数据

map.set(key,value);        

//获取数据

Var val = map.get(key);

//删除数据 , 返回一个boolean值    ,true : 删除成功 , false :删除失败

var b = map.delete(key);

//判断Map里是否存在该数据,返回一个boolean值,true : 存在 , false: 不存在

var h = map.has(key);

//遍历Map

map.forEach((key,value)=>{

        //函数体

});    

ES6提供了新的数据结构Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。

语法:

    //创建set

    var newset = new  Set();

    //添加数据

    newset.add(变量1);

在JavaScript中，数据的遍历存在多种，在ES6中提供了for…of ，用于统一所有数据结构的遍历.

语法:

 for(let val of 集合类){}

例如:

//遍历数组

for(let a of arr){}

//遍历Map,for..of与解构结合

for(let [k,v] of map){}

//遍历set集合

for(let s of set){}

//遍历对象,由于自定义对象不能直接遍历所以需要借助Object.keys()转换成`键数组`

for(let key  of  Object.keys(对象)){

console.info(`键:,值:`);

}

JS中已有的遍历方式:

rest参数,JS中的可变参数,即在函数的形参列表的最后一个参数前加  ...                       

语法:

function 函数名(参数1,参数2,...参数3){}

例如:

//Rest参数

function add(...values){

    let sum = 0;

    for(var val of values){

        sum +=val;

    }

    return sum;

}

console.info( add(2,3,4,5,6,7,8));

扩展运算符（spread）是三个点（...）。它好比rest参数的逆运算 .

    1.操作数据是数组，将一个数组转为用逗号分隔的参数序列

    2.操作数据是对象，取出参数对象的所有可遍历属性，拷贝到当前对象之中            

    语法:

        var arr = [`a`,`b`,`c`];

        function fun3(x,y,z){

        console.info([x,y,z]) ;               

      }

    fun3(arr);              //[ [`a`,`b`,`c`],undefined,undefined ]  

    fun3(...arr);            //[`a`,`b`,`c`]                            

//导入

// es5    commonJS      

const user = require("./资源");    

//ES6 

import  {user}  from"./资源" ;                    

//导出    

//es5  commonJS                                

module.exports=user对象;

//ES6

export  user对象;