var可以多次声明同一个变量--在其他编程语言是没办法想象的
var a =0;
var a = 99;（2）var会造成变量提升
(function rr() {
if(true) {
var a = 666;
}
console.log(a); //输出666
})()
ES6变量声明关键字：let 变量声明；const 常量声明。解决了var前面提到的两个缺点。
let以及const都是块级作用域。
常见面试题：
for(var a = 0; a < 3; a++) {
setTimeout(function() {
console.log(a);
}, 1000)
})
//输出 3 3 3如何将结果输出为0, 1, 2
es5处理方法 -- 用函数制造块级作用域---利用闭包实现
for(var a = 0; a < 3; a++) {
(function (a) {
setTimeout(function() {
console.log(a);
}, 1000)
})(a)
}
//输出结果0,1,2
es6处理方法 -- 更加简单明了
for(let a = 0; a < 3; a++) {
setTimeout(function() {
console.log(a);
}, 1000)
}
//输出结果为：0,1,2=================================总结===========================================================
1.Let和Const
let用来声明变量：特点：
(1)不存在变量提升
(2)存在暂时性死区，ReferenceError
(3)不允许重复声明
(4)只在声明的块级作用域内有效
const用来声明常量：特点：
(1)一旦声明必须初始化，常量的至不能变。
(2)只在声明的块级作用域内有效
(3)不会提升，存在暂时性死区，先声明后使用 。
(4)不可重复声明
const本质：
保证的并不是变量的值不得改动。而是变量指向的那个内存地址不得改动。对于简单数据类型来说，值就保存在变量指向的内存地址中，因而等同于常量。但对于复合类型的数据而言，变量指向的内存地址保存的只是一个指针，const只能保证这个指针是固定的，至于它指向的数据结构是不是可变的，这完全不能控制
块级作用域
为什么需要块级作用域？
(1)内层变量可能会覆盖外层变量
(2)用来计数的循环变量泄露为全局变量。
块级作用域中函数声明规则：
(1)允许在块级作用域中声明函数
(2)函数声明类似于var，即会提升到全局作用域或函数作用域的头部。
(3)函数声明还会提升到块级作用域的头部。
---------------------
2、函数 （箭头函数）
箭头函数
箭头函数this的指向时固定化的，这非常有利于封装回掉函数。this指向的固定化并不是因为箭头函数内部绑定this的机制，实际原因是箭头函数根本没有自己的this，导致内部函数的this就是外层代码块的this，正因为它没有this，所以不能作为构造函数。
(1)函数体内的this对象，就是定义时所在的对象，而不是运行时所在的对象。
(2)不可以当作构造函数，就是不能使用new命令
(3)不能使用arguments对象，该对象在函数体内不存在，如果要用，可以使用rest代替
(4)不能使用yield命令，因此箭头函数不能作为Generate函数。
（1）不需要function关键字来创建函数
es5创建函数
var aa = function() {}
es6创建函数
var aa = () => {}
(2)可以极大的简写函数
es5函数
var fn = function(a) {
return a + 5
}
可以利用箭头函数简写为：
var fn = a => a + 5;
简写规则：
当函数所传参数只有一个时，可以去掉(); eg: (a) => {} 简写为：a => {}
当函数体中只返回值，而没有其他操作时，可以去掉{}；eg: (a, b) => {return a+b} 简写为：(a, b) => a+b
（3）继承上下文的关键字this
es5继承上下文的关键字
var fn = function() {
}
fn.bind(this)
es6继承上下文的关键字
var fn = () => {}---------------------
3、数组
新增常用的4个方法
（1）map --映射
let arr=[66,59,80];
let result=arr.map(item => {
if(item >= 60){
return "及格"
}else{
return "不及格"
}
});
//result:["及格", "不及格", "及格"]
（2）reduce --汇总
let arr = [12,69,180,8763];
let result = arr.reduce((tmp, item, index) => {
console.log(tmp, item, index);
return tmp + item;
});
console.log(result);//求和
（3）filter --过滤
let arr=[
{title: '电源线', price: 50},
{title: '电脑', price: 13000},
{title: '键盘', price: 120},
{title: '手机', price: 9000}
];
let result=arr.filter(json=>json.price>=5000);
console.log(result);//[{title: '电脑', price: 13000},{title: '手机', price: 9000}]
（4）forEach --迭代
let arr=[12,5,8,9];
arr.forEach((item,index)=>{
console.log(index+': '+item); //0: 12 1: 5 2: 8 3: 9
});
4、函数的参数
（1）收集参数
function show(a, b, ...args){
console.log(args)
}
show(1,2,3,4,5,6) //输出[3,4,5,6]
（2）展开数组
const arr1 = [1,2,3];
const arr2 = [4,5,6];
console.log([...arr1, ...arr2]); //输出[1,2,3,4,5,6]
console.log(...arr1); //输出1，2，3
（3）默认值
const show = (a=666, b=999) => {
console.log(a); //输出666
console.log(b); //输出999
}
show();
5、解构赋值
(1)左右两边结构必须一样；
(2)右边必须是个合法的值；
(3)声明和赋值不能分开(必须在一句话里完成)；
let [a,b,c]=[1,2,3,999];
let {e,d,g}={e: 4, d: 5, f: 6, g: 7};
console.log(a,b,c,e,d,g);
//输出1 2 3 4 5 7
6、字符串
(1)多了两个新方法: startsWith endsWith
//startsWith
let str='https//http://mp.blog.csdn.net/postedit/79478118';
if(str.startsWith('http://')){
alert('普通网址');
}else if(str.startsWith('https://')){
alert('加密网址');
}else if(str.startsWith('git://')){
alert('git地址');
}else if(str.startsWith('svn://')){
alert('svn地址');
}else{
alert('其他');
}
//endsWith
let str='12121.png';
if(str.endsWith('.txt')){
alert('文本文件');
}else if(str.endsWith('.jpg')){
alert('JPG图片');
}else{
alert('其他');
}
(2)字符串模板
优点：方便字符串拼接；可以折行
let title='标题';
let content='内容';
let str='<div>\
<h1>'+title+'</h1>\
<p>'+content+'</p>\
</div>';
let str2=`<div>
<h1>${title}</h1>
<p>${content}</p>
</div>`;
参考文档：
原文：https://blog.csdn.net/barret007/article/details/79478118