1.   我们推荐你去看ECMAScript 6 入门。但如果在实际的开发任务中，由于时间原因或是学习的成本没法全面了解，那么我们强烈建议你在项目中只学习那些常用的 ES6 语法或特性，掌握这些知识也许花2个小时就能搞定，剩下的可以看书或是查文档，到时再现学现用。<br />

教程的示例代码请前往es6-demo，下载后可以结合这个讲义进行学习操作。

1. let + const 块级作用域和常量

  1.   let和const的出现让 JS 有了块级作用域，还可以像强类型语言一样定义常量。由于之前没有块级作用域以及 var 关键字所带来的变量提升，经常给我们的开发带来一些莫名其妙的问题。<br />

下面看两个简单的demo理解。

  1. // demo 1
  2. function f1() {
  3.   let n = 5;
  4.   if (true) {
  5.     let n = 10;
  6.   }
  7.   console.log(n); // 5
  8. }
  9. // demo 2
  10. const PI = 3.1415;
  11. console.log(PI); // 3.1415
  12. PI = 3;
  13. console.log(PI); // TypeError: "PI" is read-only

2. Arrows 箭头函数

  • 箭头函数简化了函数的的定义方式，一般以 “=>” 操作符左边为输入的参数，而右边则是进行的操作以及返回的值Inputs=>outputs。

  • 箭头函数根本没有自己的this，导致内部的this就是外层代码块的this。正是因为它没有this，所以也就不能用作构造函数，从而避免了this指向的问题。
    请看下面的例子。

    1. var array = [1, 2, 3];
    2. //传统写法
    3. array.forEach(function(v, i, a) {
    4.   console.log(v);
    5. });
    6. //ES6
    7. array.forEach(v = > console.log(v));
    8. 更多示例：
    9. const Template = {
    10.   test: function(){
    11.       console.log(this);
    12.       $('#event').on('click',()=>{
    13.           // 大家觉得这个 this 是什么
    14.           console.log(this);
    15.       });
    16.   }
    17. };
    18. Template.test();

    3. Class, extends, super 类的支持

    1. 回想之前，如果我们需要模拟一个js的类，一般会采用构造函数加原型的方式。
    1. function Point(x,y){
    2. this.x = x;
    3. this.y = y;
    4. }
    5. Point.prototype.toString = function () {
    6. return '(' + this.x + ', ' + this.y + ')';
    7. }
    1. ES6中添加了对类的支持，引入了class关键字（其实class在JavaScript中一直是保留字，目的就是考虑到可能在以后的新版本中会用到，现在终于派上用场了）。<br />

    JS本身就是面向对象的，ES6中提供的类实际上只是JS原型模式的包装。现在提供原生的class支持后，对象的创建，继承更加直观了，并且父类方法的调用，实例化，静态方法和构造函数等概念都更加形象化。
    下面代码展示了类在ES6中的使用。

    1. //类的定义
    2. class Animal {
    3.   //ES6中新型构造器
    4.   constructor(name) {
    5.       this.name = name;
    6.   }
    7.   //实例方法
    8.   sayName() {
    9.       console.log('My name is '+this.name);
    10.   }
    11. }
    12. //类的继承
    13. class Programmer extends Animal {
    14.   constructor(name) {
    15.       //直接调用父类构造器进行初始化
    16.       super(name);
    17.   }
    18.   program() {
    19.       console.log("I'm coding...");
    20.   }
    21. }
    22. //测试我们的类
    23. var animal=new Animal('dummy'),
    24. zf=new Programmer('zf');
    25. animal.sayName();//输出 ‘My name is dummy’
    26. zf.sayName();//输出 ‘My name is zf’
    27. zf.program();//输出 ‘I'm coding...’

    4. Enhanced Object Literals 增强的对象字面量

    对象字面量被增强了，写法更加简洁与灵活，同时在定义对象的时候能够做的事情更多了。具体表现在：

  • 可以在对象字面量里面定义原型

  • 定义方法可以不用function关键字
  • 直接调用父类方法
    这样一来，对象字面量与前面提到的类概念更加吻合，在编写面向对象的JavaScript时更加轻松方便了。
    1. //通过对象字面量创建对象
    2. var human = {
    3.   breathe() {
    4.       console.log('breathing...');
    5.   }
    6. };
    7. var worker = {
    8.   __proto__: human, //设置此对象的原型为human,相当于继承human
    9.   company: 'freelancer',
    10.   work() {
    11.       console.log('working...');
    12.   }
    13. };
    14. human.breathe();//输出 ‘breathing...’
    15. //调用继承来的breathe方法
    16. worker.breathe();//输出 ‘breathing...’

    5. Template Strings 字符串模板

    1. 字符串模板相对简单易懂些。ES6中允许使用反引号 ` 来创建字符串，此种方法创建的字符串里面可以包含由美元符号加花括号包裹的变量${vraible}。如果你使用过像C#等后端强类型语言的话，对此功能应该不会陌生。
    1. //产生一个随机数
    2. var num = Math.random();
    3. //将这个数字输出到console
    4. console.log(`your num is ${num}`);
    5. let name = 'guoyongfeng';
    6. let age = 18;
    7. console.log(`${name} was ${age}`)

    6. Destructuring 解构

    1. Destructuring是解构的意思，ES6允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构（Destructuring）。<br />      比如若一个函数要返回多个值，常规的做法是返回一个对象，将每个值做为这个对象的属性返回。但在ES6中，利用解构这一特性，可以直接返回一个数组，然后数组中的值会自动被解析到对应接收该值的变量中。
    1. var [x,y]=getVal(),//函数返回值的解构
    2.   [name,,age]=['zf','male','secrect'];//数组解构
    3. function getVal() {
    4.   return [ 1, 2 ];
    5. }
    6. console.log('x:'+x+', y:'+y);//输出：x:1, y:2
    7. console.log('name:'+name+', age:'+age);//输出： name:zf, age:secrect
    8. 数组、对象和字符串的解构赋值示例：
    9. 'use strict';
    10. // 数组的解构赋值
    11. let [foo, [[bar], baz]] = [1, [[2], 3]];
    12. console.log(foo); // 1
    13. console.log(bar); // 2
    14. console.log(baz); // 3
    15. // 对象的解构赋值
    16. var { foo, bar } = { foo: "aaa", bar: "bbb" };
    17. console.log(foo);   // "aaa"
    18. console.log(bar );  // "bbb"
    19. // 字符串的解构赋值
    20. const [a, b, c, d, e] = 'hello';
    21. console.log(a + b + c + e); // 'hello'

    7. Default + Rest + Spread

    7.1 Default 默认参数值

    1. 现在可以在定义函数的时候指定参数的默认值了，而不用像以前那样通过逻辑或操作符来达到目的了。
    1. function sayHello(name){
    2.   //传统的指定默认参数的方式
    3.   var name=name||'dude';
    4.   console.log('Hello '+name);
    5. }
    6. //运用ES6的默认参数
    7. function sayHello2(name='dude'){
    8.   console.log(`Hello ${name}`);
    9. }
    10. sayHello();//输出：Hello dude
    11. sayHello('zf');//输出：Hello zf
    12. sayHello2();//输出：Hello dude
    13. sayHello2('zf');//输出：Hello zf

    7.2 Rest 剩余参数

    1. 不定参数是在函数中使用命名参数同时接收不定数量的未命名参数。这只是一种语法糖，在以前的JavaScript代码中我们可以通过 arguments 变量来达到这一目的。<br />
    不定参数的格式是三个句点后跟代表所有不定参数的变量名。比如下面这个例子中，…x代表了所有传入add函数的参数。
    1. 一个简单示例：
    2. // rest
    3. function restFunc(a, ...rest) {
    4. console.log(a)
    5. console.log(rest)
    6. }
    7. restFunc(1);
    8. restFunc(1, 2, 3, 4);
    9. 再看一个：
    10. //将所有参数相加的函数
    11. function add(...x){
    12.   return x.reduce((m,n)=>m+n);
    13. }
    14. //传递任意个数的参数
    15. console.log(add(1,2,3));//输出：6
    16. console.log(add(1,2,3,4,5));//输出：15

    7.3 Spread 扩展操作符

    1. 扩展操作符则是另一种形式的语法糖，它允许传递数组或者类数组直接做为函数的参数而不用通过apply。
    1. var people=['zf','John','Sherlock'];
    2. function sayHello(people1,people2,people3){
    3.   console.log(`Hello ${people1},${people2},${people3}`);
    4. }
    5. //但是我们将一个数组以拓展参数的形式传递，它能很好地映射到每个单独的参数
    6. sayHello(...people);//输出：Hello zf,John,Sherlock
    7. //而在以前，如果需要传递数组当参数，我们需要使用函数的apply方法
    8. sayHello.apply(null,people);//输出：Hello zf,John,Sherlock

    8. Map、Set 和 WeakMap、WeakSet

    1. 这些是新加的集合类型，提供了更加方便的获取属性值的方法，不用像以前一样用hasOwnProperty来检查某个属性是属于原型链上的呢还是当前对象的。同时，在进行属性值添加与获取时有专门的get，set方法。
    1. // Sets
    2. var s = new Set();
    3. s.add("hello").add("goodbye").add("hello");
    4. s.size === 2;
    5. s.has("hello") === true;
    6. // Maps
    7. var m = new Map();
    8. m.set("hello", 42);
    9. m.set(s, 34);
    10. m.get(s) == 34;
    1. 有时候我们会把对象作为一个对象的键用来存放属性值，普通集合类型比如简单对象会阻止垃圾回收器对这些作为属性键存在的对象的回收，有造成内存泄漏的危险。而WeakMap,WeakSet则更加安全些，这些作为属性键的对象如果没有别的变量在引用它们，则会被回收释放掉，具体还看下面的例子。
    1. // Weak Maps
    2. var wm = new WeakMap();
    3. wm.set(s, { extra: 42 });
    4. wm.size === undefined
    5. // Weak Sets
    6. var ws = new WeakSet();
    7. ws.add({ data: 42 });//因为添加到ws的这个临时对象没有其他变量引用它，所以ws不会保存它的值，也就是说这次添加其实没有意思

    9. Proxies

    1. Proxy可以监听对象身上发生了什么事情，并在这些事情发生后执行一些相应的操作。一下子让我们对一个对象有了很强的追踪能力，同时在数据绑定方面也很有用处。
    1. //定义被侦听的目标对象
    2. var engineer = { name: 'Joe Sixpack', salary: 50 };
    3. //定义处理程序
    4. var interceptor = {
    5. set: function (receiver, property, value) {
    6.   console.log(property, 'is changed to', value);
    7.   receiver[property] = value;
    8. }
    9. };
    10. //创建代理以进行侦听
    11. engineer = Proxy(engineer, interceptor);
    12. //做一些改动来触发代理
    13. engineer.salary = 60;//控制台输出：salary is changed to 60
    1. 上面代码我已加了注释，这里进一步解释。对于处理程序，是在被侦听的对象身上发生了相应事件之后，处理程序里面的方法就会被调用，上面例子中我们设置了set的处理函数，表明，如果我们侦听的对象的属性被更改，也就是被set了，那这个处理程序就会被调用，同时通过参数能够得知是哪个属性被更改，更改为了什么值。

    10. Object assign

    1. Object.assign 用于对象的合并，ES6对object做了很多扩展，assign是最值得点评的。想必你很熟悉jquery提供的extend接口，那么ES6的Object.assign就是从语法层面做了这件事情，是不是很nice。
    1. var target = { a: 1 };
    2. var source1 = { b: 2 };
    3. var source2 = { c: 3 };
    4. Object.assign(target, source1, source2);
    5. console.log(target); // {a:1, b:2, c:3}

    11. Promises

    1. ES6的Promise是一个非常重要的特性，它是处理异步操作的一种模式。有了它，JavaScript异步嵌套的问题算是得到了比较好的解决。同时，Promise也是ES7中async/await的基础。<br />
    我们来看ES6中的Promise对象的使用：
    1. //创建promise
    2. var promise = new Promise(function(resolve, reject) {
    3.   // 进行一些异步或耗时操作
    4.   if ( /*如果成功 */ ) {
    5.       resolve("Stuff worked!");
    6.   } else {
    7.       reject(Error("It broke"));
    8.   }
    9. });
    10. //绑定处理程序
    11. promise.then(function(result) {
    12.   //promise成功的话会执行这里
    13.   console.log(result); // "Stuff worked!"
    14. }, function(err) {
    15.   //promise失败会执行这里
    16.   console.log(err); // Error: "It broke"
    17. });
    18. 使用promise模拟一个ajax方法的demo用于大家理解
    19. var getJSON = function(url) {
    20. var promise = new Promise(function(resolve, reject){
    21.   var client = new XMLHttpRequest();
    22.   client.open("GET", url);
    23.   client.onreadystatechange = handler;
    24.   client.responseType = "json";
    25.   client.setRequestHeader("Accept", "application/json");
    26.   client.send();
    27.   function handler() {
    28.     if ( this.readyState !== 4 ) {
    29.       return;
    30.     }
    31.     if (this.status === 200) {
    32.       resolve(this.response);
    33.     } else {
    34.       reject(new Error(this.statusText));
    35.     }
    36.   };
    37. });
    38. return promise;
    39. };
    40. getJSON("/posts.json").then(function(json) {
    41. console.log('Contents: ' + json);
    42. }, function(error) {
    43. console.error('出错了', error);
    44. });

    12. Decorator

    1. 修饰器（Decorator）是一个表达式，用来修改类的行为。这是ES7的一个提案，目前Babel（babel-plugin-transform-decorators-legacy）转码器已经支持。<br />      不知道大家有没有使用过java的spring mvc，其中的注解就跟这个比较相似，学习React的话可以重点关注下这个语法，因为后面使用redux类库的时候会频繁的用到decorator。<br />      首先说下如何配置babel的插件来进行decorator的解析。
    1. // 官网提供了babel-plugin-transform-decorators这个插件来解析，但是我发现不work，就找了下面这个
    2. $ npm install babel-plugin-transform-decorators-legacy --save-dev
    配置.babelrc的plugins字段。
    1. {
    2. "presets": ["es2015", "react", "stage-0"],
    3. "plugins": ["transform-decorators-legacy"]
    4. }
    ok，接下来来段使用decorator的示例代码
    function testable(target) {
target.isTestable = true;
}
@testable
class MyTestableClass {}
console.log(MyTestableClass.isTestable) // true

    13. Modules 模块

    在ES6标准中，JavaScript原生支持module了。这种将JS代码分割成不同功能的小块进行模块化的概念是在一些三方规范中流行起来的，比如CommonJS和AMD模式。<br />      将不同功能的代码分别写在不同文件中，各模块只需导出公共接口部分，然后通过模块的导入的方式可以在其他地方使用。不过，还是有很多细节的地方需要注意，我们看例子：<br />
    简单使用方式：
    // point.js
export class Point {
   constructor (x, y) {
       public x = x;
       public y = y;
   }
}
// myapp.js
//这里可以看出，尽管声明了引用的模块，还是可以通过指定需要的部分进行导入
import Point from "point";
var origin = new Point(0, 0);
console.log(origin);

    13.1 export

    // demo1：简单使用
export var firstName = 'Michael';
export var lastName = 'Jackson';
export var year = 1958;
// 等价于
var firstName = 'Michael';
var lastName = 'Jackson';
var year = 1958;
export {firstName, lastName, year};
// demo2：还可以这样
function v1() { ... }
function v2() { ... }
export {
v1 as streamV1,
v2 as streamV2,
v2 as streamLatestVersion
};
// demo3：需要注意的是
// 报错
function f() {}
export f;
// 正确
export function f() {};
我们再来看一下export的默认输出：
export default function () {
console.log('foo');
}

    13.2 import

    为了给用户提供方便，让他们不用阅读文档就能加载模块，就要用到export default命令，为模块指定默认输出。这样其他模块加载该模块时，import命令可以为该匿名函数指定任意名字。<br />     需要注意的是，这时import命令后面，不使用大括号。<br />     最后需要强调的是：ES6模块加载的机制，与CommonJS模块完全不同。CommonJS模块输出的是一个值的拷贝，而ES6模块输出的是值的引用。<br />      CommonJS模块输出的是被输出值的拷贝，也就是说，一旦输出一个值，模块内部的变化就影响不到这个值。<br />
    ES6模块的运行机制与CommonJS不一样，它遇到模块加载命令import时，不会去执行模块，而是只生成一个动态的只读引用。等到真的需要用到时，再到模块里面去取值，换句话说，ES6的输入有点像Unix系统的”符号连接“，原始值变了，import输入的值也会跟着变。因此，ES6模块是动态引用，并且不会缓存值，模块里面的变量绑定其所在的模块。
    // 1
import $ from 'jquery';
// 2
import {firstName, lastName, year} from './profile';
// 3
import React, { Component, PropTypes } from 'react';
// 4
import * as React from 'react';

    14. async/await 异步操作

    JavaScript 中实现异步操作最简单的方式。