Asynchronous（異步處理-Generator）

Generator 是 ES6 標準中的異步編程方式
    通俗來講 Generator 是一個帶星號的“函式”（它并不是真正的函式，下面的代碼會為你驗證），可以配合 yield 關鍵字來暫停或者執行函式，

Generator（生成器）
    Generator 也是一種異步編程解決方案，它最大的特點就是可以交出函式的執行權，
    Generator 函式可以看出是異步任務的容器，需要暫停的地方，都用 yield 語法來標注，
    Generator 函式一般配合 yield 使用，Generator 函式最后回傳的是迭代器

  function* gen() {
    let a = yield 111;
    console.log(a);
    let b = yield 222;
    console.log(b);
    let c = yield 333;
    console.log(c);
    let d = yield 444;
    console.log(d);
  }
  let t = gen();
  t.next(1); // 第一次呼叫next函式時，傳遞的引數無效，故無列印結果 執行到 let a = yield 111; 即結束，console.log(a);未執行，所以未列印
  t.next(2); // a輸出2;
  t.next(3); // b輸出3;
  t.next(4); // c輸出4;
  t.next(5); // d輸出5;

// 第一次的 next 雖然執行了但是并未輸出結果，后面的每次執行 next 會把引數傳入然后列印出來，
// 等到最后一次 next 對應的 yield 執行完之后，控制臺會列印 “{value: undefined, done: true}” 的輸出結果，
// 標識該 Generator 函式已經執行完畢，即 done：true

function* gen() {
    console.log('enter');
    let a = yield 1;
    let b = yield (function () {
      return 2;
    })();
    return 3;
  }
  var g = gen(); // 阻塞住，不會執行任何陳述句
  console.log(typeof g); // 回傳 object 這里不是 "function"
  console.log(g.next());
  console.log(g.next());
  console.log(g.next());
  console.log(g.next());
  // output:
  // { value: 1, done: false }
  // { value: 2, done: false }
  // { value: 3, done: true }
  // { value: undefined, done: true }

Yield

yield 同樣也是 ES6 的新關鍵詞，配合 Generator 執行以及暫停，
yield 關鍵詞最后回傳一個迭代器物件，該物件有 value 和 done 兩個屬性，其中 done 屬性代表回傳值以及是否完成，
yield 配合著 Generator，再同時使用 next 方法，可以主動控制 Generator 執行進度，

  function* gen1() {
    yield 1;
    yield* gen2();
    yield 4;
  }
  function* gen2() {
    yield 2;
    yield 3;
  }
  var g = gen1();
  console.log(g.next());
  console.log(g.next());
  console.log(g.next());
  console.log(g.next());
  // output:
  // { value: 1, done: false }
  // { value: 2, done: false }
  // { value: 3, done: false }
  // { value: 4, done: false }
  // {value: undefined, done: true}

// 使用 yield 關鍵詞的話還可以配合著 Generator 函式嵌套使用，從而控制函式執行進度，
// 這樣對于 Generator 的使用，以及最終函式的執行進度都可以很好地控制，從而形成符合你設想的執行順序，
// 即便 Generator 函式相互嵌套，也能通過呼叫 next 方法來按照進度一步步執行

Thunk 函式

接收一定的引數，會生產出定制化的函式，最后使用定制化的函式去完成想要實作的功能

  let isString = (obj) => {
    return Object.prototype.toString.call(obj) === '[object String]';
  };
  let isFunction = (obj) => {
    return Object.prototype.toString.call(obj) === '[object Function]';
  };
  let isArray = (obj) => {
    return Object.prototype.toString.call(obj) === '[object Array]';
  };

  let isType = (type) => {
    return (obj) => {
      return Object.prototype.toString.call(obj) === `[object ${type}]`;
    };
  };


  let isString = isType('String');
  let isArray = isType('Array');
  isString('123'); // true
  isArray([1, 2, 3]); // true

Generator 和 thunk 結合

  const readFileThunk = (filename) => {
    return (callback) => {
      fs.readFile(filename, callback);
    };
  };
  const gen = function* () {
    const data1 = yield readFileThunk('1.txt');
    console.log(data1.toString());
    const data2 = yield readFileThunk('2.txt');
    console.log(data2.toString);
  };

  let g = gen();
  g.next().value((err, data1) => {
    g.next(data1).value((err, data2) => {
      g.next(data2);
    });
  });

  // 很多層的嵌套，可讀性不強

// 改進后

  function run(gen) {
    const next = (err, data) => {
      let res = gen.next(data);
      if (res.done) return;
      res.value(next);
    };
    next();
  }
  run(g);

Generator 和 Promise 結合

  // 最后包裝成 Promise 物件進行回傳
  const readFilePromise = (filename) => {
    return new Promise((resolve, reject) => {
      fs.readFile(filename, (err, data) => {
        if (err) {
          reject(err);
        } else {
          resolve(data);
        }
      });
    }).then((res) => res);
  };
  // 這塊和上面 thunk 的方式一樣
  const gen = function* () {
    const data1 = yield readFilePromise('1.txt');
    console.log(data1.toString());
    const data2 = yield readFilePromise('2.txt');
    console.log(data2.toString);
  };
  // 這塊和上面 thunk 的方式一樣
  function run(gen) {
    const next = (err, data) => {
      let res = gen.next(data);
      if (res.done) return;
      res.value.then(next);
    };
    next();
  }
  run(g);

co 函式庫

co 函式庫是著名程式員 TJ 發布的一個小工具，用于處理 Generator 函式的自動執行，
核心原理其實就是上面講的通過和 thunk 函式以及 Promise 物件進行配合，包裝成一個庫.

co 函式庫可以自動執行 Generator 函式，它的處理原理是什么呢？

    1.因為 Generator 函式就是一個異步操作的容器，它需要一種自動執行機制，co 函式接受 Generator 函式作為引數，并最后回傳一個 Promise 物件，
    2.在回傳的 Promise 物件里面，co 先檢查引數 gen 是否為 Generator 函式，如果是，就執行該函式；如果不是就回傳，并將 Promise 物件的狀態改為 resolved，
    3.co 將 Generator 函式的內部指標物件的 next 方法，包裝成 onFulfilled 函式，這主要是為了能夠捕捉拋出的錯誤，
    4.關鍵的是 next 函式，它會反復呼叫自身，```