内容：
1.ES6介绍及基础
2.模块、类和继承
3.ES6高级特性
4.Generator和Iterator
5.异步编程
内容参考：《ES6 标准入门》
ES6标准阅读链接：http://es6.ruanyifeng.com/
一、ES6介绍及基础
1.什么是ES6
ECMAScript 6.0（以下简称 ES6）是 JavaScript 语言的下一代标准，已经在 2015 年 6 月正式发布了。它的目标，是使得 JavaScript 语言可以用来编写复杂的大型应用程序，成为企业级开发语言
2.JavaScript版本
JavaScript有很多版本，具体版本如下：
3.ES6基础
(1)let
ES6 新增了let命令，用来声明变量。它的用法类似于var，但是let所声明的变量，只在let命令所在的代码块内有效，另外let命令可以创建块级作用域
let和var的区别：
1 {
2 let a = 10;
3 var b = 1;
4 }
5
6 console.log(a) // ReferenceError: a is not defined.
7 console.log(b) // 1
8 // 结果表明，let声明的变量只在它所在的代码块有效
9
10
11 // var和let的区别:
12 // 下面的代码如果使用var，最后输出的是10:
13 var a = [];
14 for (var i = 0; i < 10; i++) {
15 a[i] = function () {
16 console.log(i);
17 };
18 }
19 a[6]() // 10
20
21
22 // 如果使用let，声明的变量仅在块级作用域内有效，最后输出的是 6。
23 var a = [];
24 for (let i = 0; i < 10; i++) {
25 a[i] = function () {
26 console.log(i);
27 };
28 }
29 a[6]() // 6
for循环的特别之处：
1 // 设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域
2 // 例如下面这段代码:
3 for (let i = 0; i < 3; i++) {
4 let i = ‘abc‘;
5 console.log(i);
6 }
7 // abc
8 // abc
9 // abc
另外，var命令会发生”变量提升“现象，即变量可以在声明之前使用，值为undefined。这种现象多多少少是有些奇怪的，按照一般的逻辑，变量应该在声明语句之后才可以使用。
为了纠正这种现象，let命令改变了语法行为，它所声明的变量一定要在声明后使用，否则报错
1 // var 的情况 2 console.log(foo); // 输出undefined 3 var foo = 2; 4 5 // let 的情况 6 console.log(bar); // 报错ReferenceError 7 let bar = 2;
(2)const
const声明一个只读的常量；一旦声明，常量的值就不能改变，这意味着，const一旦声明变量，就必须立即初始化，不能留到以后赋值；const的作用域与let命令相同：只在声明所在的块级作用域内有效
1 const PI = 3.1415; 2 PI // 3.1415 3 4 PI = 3; 5 // TypeError: Assignment to constant variable. 6 // 改变常量的值会报错 7 8 9 const foo; 10 // SyntaxError: Missing initializer in const declaration
二、模块、类和继承
1.模块module
历史上，JavaScript 一直没有模块（module）体系，无法将一个大程序拆分成互相依赖的小文件，再用简单的方法拼装起来。其他语言都有这项功能，比如 Ruby 的require、Python 的import，甚至就连 CSS 都有@import，但是 JavaScript 任何这方面的支持都没有，这对开发大型的、复杂的项目形成了巨大障碍
在 ES6 之前，社区制定了一些模块加载方案，最主要的有 CommonJS 和 AMD 两种。前者用于服务器，后者用于浏览器。ES6 在语言标准的层面上，实现了模块功能，而且实现得相当简单，完全可以取代 CommonJS 和 AMD 规范，成为浏览器和服务器通用的模块解决方案；ES6 模块的设计思想是尽量的静态化，使得编译时就能确定模块的依赖关系，以及输入和输出的变量。CommonJS 和 AMD 模块，都只能在运行时确定这些东西。比如，CommonJS 模块就是对象，输入时必须查找对象属性
ES6 模块不是对象，而是通过export命令显式指定输出的代码，再通过import命令输入：
1 // export
2 export function stat() {}
3 export function exists() {}
4 export function readFile () {}
5 // import
6 import { stat, exists, readFile } from ‘fs‘;
上面代码的实质是从fs模块加载 3 个方法，其他方法不加载。这种加载称为“编译时加载”或者静态加载，即 ES6 可以在编译时就完成模块加载，效率要比 CommonJS 模块的加载方式高
模块详细内容：http://es6.ruanyifeng.com/#docs/module
2.类class
下面是ES5和ES6定义类的写法：
1 // ES5:
2 function Point(x, y) {
3 this.x = x;
4 this.y = y;
5 }
6
7 Point.prototype.toString = function () {
8 return ‘(‘ + this.x + ‘, ‘ + this.y + ‘)‘;
9 };
10
11 var p = new Point(1, 2);
12
13
14 //ES6:
15 class Point {
16 constructor(x, y) {
17 this.x = x;
18 this.y = y;
19 }
20
21 toString() {
22 return ‘(‘ + this.x + ‘, ‘ + this.y + ‘)‘;
23 }
24 }
类详细介绍：http://es6.ruanyifeng.com/#docs/class
3.继承inherit
ES6中Class 可以通过extends关键字实现继承，这比 ES5 的通过修改原型链实现继承，要清晰和方便很多
1 class Point {
2 constructor(x, y) {
3 this.x = x;
4 this.y = y;
5 }
6 }
7
8
9 class ColorPoint extends Point {
10 constructor(x, y, color) {
11 super(x, y); // 调用父类的constructor(x, y)
12 this.color = color;
13 }
14
15 toString() {
16 return this.color + ‘ ‘ + super.toString(); // 调用父类的toString()
17 }
18 }
继承详细内容：http://es6.ruanyifeng.com/#docs/class-extends
三、ES6高级特性
1.变量的解构赋值
ES6中允许这样的赋值方式：
1 let [a, b, c] = [1, 2, 3] 2 3 let [foo, [[bar], baz]] = [1, [[2], 3]]; 4 foo // 1 5 bar // 2 6 baz // 3 7 8 let [ , , third] = ["foo", "bar", "baz"]; 9 third // "baz" 10 11 let [x, , y] = [1, 2, 3]; 12 x // 1 13 y // 3 14 15 let [head, ...tail] = [1, 2, 3, 4]; 16 head // 1 17 tail // [2, 3, 4] 18 19 let [x, y, ...z] = [‘a‘]; 20 x // "a" 21 y // undefined 22 z // []
另外如果解析不成功，值就为undefined，如下所示：
1 let [foo] = []; 2 let [bar, foo] = [1]; 3 // 以上两种情况都属于解构不成功，foo的值都会等于undefined
更多细节：http://es6.ruanyifeng.com/#docs/destructuring
2.spread 和 rest
(1)拓展运算符spread
(2)rest
3.template
4.symbol
5.map和set
四、Generator和Iterator
五、异步编程
原文地址：https://www.cnblogs.com/wyb666/p/9393336.html