ES6的简介
ECMAScript 6 简称 ES6，是 JavaScript 语言的下一代标准，已经在2015年6月正式发布了。它的目标是使得 JavaScript 语言可以用来编写复杂的大型应用程序，成为企业级开发语言。 ECMAScript 和 JavaScript 的关系：前者是后者的语法规格，后者是前者的一种实现 Babel：将ES6代码转为ES5代码：https://babeljs.io/
ES6的基础语法
let的特性
用来声明标变量。它的用法类似于var，但声明的变量只在let命令所在的代码块内有效： 1. 存在块级作用域{} 2. 不存在声明提升 3. 不允许重复声明{包括普通函数和函数参数}
代码语言：javascript复制var a=10;
if(a>5){
var c=200;
let b=100;
}
console.log(c);//200
console.log(b);//报错 not defindconst的特性
用来声明变量，用法和var类似 （注意：不允许重复赋值）
代码语言：javascript复制//const 不允许重复赋值 其他参照let
const q=5;
q=20;//报错
console.log(q);解构赋值
简化数组和对象中信息的提取。 ES6前，我们一个一个获取对象信息； ES6后，解构能让我们从对象或者数组里取出数据存为变量
代码语言：javascript复制<body>
<script type="text/javascript">
//解构赋值
let [a,b,c]=[1,2,3];
console.log(a,b,c);//1 2 3
let [d=10,e]=[2];
//a的默认赋值是10,然后赋值为2,b是没有赋值
console.log(d,e); //2 undefined
let f;
let[g=2]=[f];
//a不会变为没有被赋值
console.log(g);//2
//对象赋值
let{h,i}={h:"111",i:"222"};
console.log(h,i);//111 222
let {j,k}={j:111};
console.log(j,k);//111 undefined
let {l,m=5}={l:1};
console.log(l,m);//1 5
</script>
</body>模板字符串
解决了 ES5 在字符串功能上的痛点。 第一个用途：字符串拼接。将表达式嵌入字符串中进行拼接，用 `` 和 ${}来界定。
代码语言：javascript复制// es5
var name1 = "bai";
console.log('hello' name1);
// es6
const name2 = "ming";
console.log(`hello${name2}`);第二个用途：在ES5时我们通过反斜杠来做多行字符串拼接。ES6反引号 `` 直接搞定。
代码语言：javascript复制// es5
var msg = "Hi
man!";
// es6
const template = `<div>
<span>hello world</span>
</div>`;另外：includes repeat
代码语言：javascript复制// includes：判断是否包含然后直接返回布尔值
let str = 'hahah';
console.log(str.includes('y')); // false
// repeat: 获取字符串重复n次
let s = 'he';
console.log(s.repeat(3)); // 'hehehe'箭头函数
函数的快捷写法。不需要 function 关键字来创建函数，省略 return 关键字 箭头函数小细节：当你的函数有且仅有一个参数的时候，是可以省略掉括号的；当你函数中有且仅有一个表达式的时候可以省略{}
代码语言：javascript复制//ES5
function foo(){
return 1;
}
console.log(foo());//1
//ES6箭头函数
let fo = ()=>1;
console.log(fo())//1继承当前上下文的 this 关键字：javaScript语言的this对象一直是一个令人头痛的问题，这是因为setTimeout中的this指向的是全局对象。
代码语言：javascript复制//this作用域
//ES5 作用域在a内
var name="Nick";
var a={name:"Amy",say:function(){console.log(this.name "你好呀")}};
a.say();//Amy你好呀
//ES6
//指向定义是所在的作用域,而不是执行时所在的作用域
var name="Nick";
var a={name:"Amy",say:()=>{console.log(this.name "你好呀")}};
a.say();//Nick你好呀
//相当于下面的代码,作用域是window;
var a={};
a.name="Amy";
a.say=()=>{console.log(this.name "你好呀")};
a.say();//Nick你好呀生成器
生成器（ generator）是能返回一个迭代器的函数。
生成器函数也是一种函数，最直观的表现就是比普通的function多了个星号*，在其函数体内可以使用yield关键字,有意思的是函数会在每个yield后暂停。
这里生活中有一个比较形象的例子。咱们到银行办理业务时候都得向大厅的机器取一张排队号。你拿到你的排队号，机器并不会自动为你再出下一张票。也就是说取票机“暂停”住了，直到下一个人再次唤起才会继续吐票。
迭代器：当你调用一个generator时，它将返回一个迭代器对象。这个迭代器对象拥有一个叫做next的方法来帮助你重启generator函数并得到下一个值。next方法不仅返回值，它返回的对象具有两个属性：done和value。value是你获得的值，done用来表明你的generator是否已经停止提供值。继续用刚刚取票的例子，每张排队号就是这里的value，打印票的纸是否用完就这是这里的done。
代码语言：javascript复制// 生成器
function *createIterator() {
yield 1;
yield 2;
yield 3;
}
// 生成器能像正规函数那样被调用，但会返回一个迭代器
let iterator = createIterator();
console.log(iterator.next().value); // 1
console.log(iterator.next().value); // 2
console.log(iterator.next().value); // 3
function *foo(x){
yield x 1;
yield x 2;
return x 3;
}
var f=foo(1);
//done代表执行过,第三个值为true表示该函数已经执行完毕
console.log(f.next(),f.next(),f.next());//{value: 2, done: false}done: falsevalue: 2__proto__: Object {value: 3, done: false} {value: 4, done: true}用生成器写一个斐波那契数列
代码语言：javascript复制//生成器写斐波那契数列
function *feibo(x){
var a=0;
var b=1;
for(var i=0;i<x;i ){
yield a;
var t=a b;
a=b;
b=t;
}
}
var f=feibo(10);
for(let i of f){
console.log(i);
}ES6中类的定义
ES6引入了Class（类）这个概念。
代码语言：javascript复制 <script type="text/javascript">
class Animal {
//构造函数
constructor() {
this.type = 'animal';
}
//类中的方法
says(say) {
console.log(this.type ' says ' say);
}
}
let animal = new Animal();
animal.says('hello'); //animal says hello
class Cat extends Animal {
constructor() {
super();//实现父类对象
this.type = 'cat';
}
}
let cat = new Cat();
cat.says('hello'); //cat says hello
</script>上面代码首先用class定义了一个“类”，可以看到里面有一个constructor方法，这就是构造方法，而this关键字则代表实例对象。简单地说，constructor内定义的方法和属性是实例对象自己的，而constructor外定义的方法和属性则是所有实力对象可以共享的。
Class之间可以通过extends关键字实现继承，这比ES5的通过修改原型链实现继承，要清晰和方便很多。上面定义了一个Cat类，该类通过extends关键字，继承了Animal类的所有属性和方法。
super关键字，它指代父类的实例（即父类的this对象）。子类必须在constructor方法中调用super方法，否则新建实例时会报错。这是因为子类没有自己的this对象，而是继承父类的this对象，然后对其进行加工。如果不调用super方法，子类就得不到this对象。
ES6的继承机制，实质是先创造父类的实例对象this（所以必须先调用super方法），然后再用子类的构造函数修改this。
ES6中set方法
<script type="text/javascript">
var a=new Set([1,2,3,4,5,5]);
console.log(a);
var b=[...a]
//扩展运算符... 返回的是数组
console.log(b);
// for of 用来遍历集合或者数组
for(let i of a){
console.log(i);
}
for(let i of b){
console.log(i);
}
a.add(9);//添加
console.log(a);
console.log(a.has(9));//判断是否含有该元素
a.delete(9);//删除某元素
console.log(a.has(9));
a.clear();//清空集合
console.log(a);
//使用回掉函数遍历每个成员
a.forEach((value,key)=>console.log(value*2,key*2));
</script>ES6中的map
<script type="text/javascript">
//map的定义以及使用
var a=new Map([["name","Nick"],["age","18"]]);
console.log(a);//Map(2) {"name" => "Nick", "age" => "18"}
a.set("Amy",19);
console.log(a);Map(3) {"name" => "Nick", "age" => "18", "Amy" => 19}
//具体的使用方法和set相似
</script>总结：以上就是ES6的基础语法，可以说这20%的语法，在ES6的日常使用中占了80%
参考文章链接：http://bxm0927.github.io/2017/06/24/es6_study/
