Promise 在回调函数的基础上，反转了控制，优化了异步的写法

    某个对象具有一个 Symbol.iterator 方法被称为可迭代对象，

    1. var obj = {
    2.     [Symbol.iterator] : function () {}
    3. }

    调用 Symbol.iterator 方法返回一个迭代器生成函数，执行生成函数返回迭代器

    1. obj[Symbol.iterator]()

    迭代器是一个对象，根据迭代器协议，迭代器一定具有 next 方法，返回{value,done}，非必须具有return，throw 方法

    1. {
    2.      next: function () {} 
    3. }

    除了for...of循环以外，扩展运算符（...）、解构赋值和Array.from方法内部调用的，都是遍历器接口。可以直接遍历迭代器，

    1. for (let value of obj[Symbol.iterator]())

    也可以遍历可迭代对象

    1. for (let value of obj)

    迭代器可以自己实现

    也可以使用生成器函数生成

    Symbol.iterator 其实也是迭代器生成方法

    生成器函数，返回一个generator，配合 yield 关键字，可以自定义 迭代规则
    generator 就是一个迭代器

    生成器 yield 的是异步操作

    1. function fetch() {
    2.     return new Promise(function (resolve, reject) {
    3.         setTimeout(() => {
    4.             resolve({"json": "success"})
    5.         }, 1000);
    6.     })
    7. }
    9. function* gen(){
    10.   var url = 'http://dict.qq.com/dict?q=dd';
    11.   var result = yield fetch(url);
    12.   console.log(result);
    13. }
    14. var g = gen()
    15. var result = g.next()
    16. result.value.then(function (data) {
    17.     return data;
    18. }).then(function (data) {
    19.     g.next(data);
    20. })

    虽然 Generator 函数将异步操作表示得很简洁，但是流程管理却不方便
    thunk函数实际上有些类似于JavaScript函数柯里化，

    1. function curry (fn) {
    2.   const args1 = Array.prototype.slice.call(arguments, 1)
    3.   return function () {
    4.     const args2 = Array.from(arguments)
    5.     const arr = args1.concat(args2)
    6.     return fn.apply(this, arr)
    7.   }
    8. }
    9. // 需要柯里化的sum函数
    10. const sum = (a, b) => {
    11.   return a + b
    12. }
    13. curry(sum, 1)(2)   // 3

    async 函数自带执行器

    co 函数，yeild 命令后面只能是 thunk 和 promise，
    async 函数的 await 后面可以是 promise 和原始类型值，