摘要：提取函數(shù)方便使用暴露把函數(shù)包起來(lái)，返回執(zhí)行不帶參數(shù)的函數(shù)，返回如果是函數(shù)，直接執(zhí)行，指定作域判斷等價(jià)于，判斷函數(shù)是否執(zhí)行完根據(jù)返回值是否，執(zhí)行完就通過(guò)返回，外部將會(huì)執(zhí)行函數(shù)帶參數(shù)用于修改上一次結(jié)果，引擎會(huì)忽略第一次執(zhí)行時(shí)參數(shù)用于捕獲錯(cuò)誤執(zhí)行

/**
 * 提取slice()函數(shù)方便使用
 */

var slice = Array.prototype.slice;

/**
 * 暴露 `co`.
 */

module.exports = co["default"] = co.co = co;

/**
 * 把generator函數(shù) `fn` 包起來(lái)，返回promise
 * This is a separate function so that
 * every `co()` call doesn"t create a new,
 * unnecessary closure.
 *
 * @param {GeneratorFunction} fn
 * @return {Function}
 * @api public
 */

co.wrap = function (fn) {
  createPromise.__generatorFunction__ = fn;
  return createPromise;
  function createPromise() {
    return co.call(this, fn.apply(this, arguments));
  }
};

/**
 * 執(zhí)行不帶參數(shù)的generator函數(shù)，返回promise
 *
 * @param {Function} fn
 * @return {Promise}
 * @api public
 */

function co(gen) {
  var ctx = this;
  var args = slice.call(arguments, 1);

  // we wrap everything in a promise to avoid promise chaining,
  // which leads to memory leak errors.
  // see https://github.com/tj/co/issues/180
  return new Promise(function(resolve, reject) {
    //如果是函數(shù)，直接執(zhí)行，apply指定作域
    if (typeof gen === "function") gen = gen.apply(ctx, args);
    // 判斷等價(jià)于 !(gen && typeof gen.next === "function")，判斷generator函數(shù)是否執(zhí)行完（根據(jù)返回值是否Iterator Object），執(zhí)行完就通過(guò)resolve返回，外部將會(huì)執(zhí)行`.then`函數(shù)
    if (!gen || typeof gen.next !== "function") return resolve(gen);

    onFulfilled();

    /**
     * .next帶參數(shù)用于修改上一次yield結(jié)果，V8引擎會(huì)忽略第一次執(zhí)行時(shí)參數(shù)
     * try/catch 用于捕獲錯(cuò)誤
     * 執(zhí)行完的結(jié)果交給自定義的next函數(shù),res結(jié)構(gòu)應(yīng)該是 {value, done}
     */

    function onFulfilled(res) {
      var ret;
      try {
        ret = gen.next(res);
      } catch (e) {
        return reject(e);
      }
      next(ret);
      return null;
    }

    /**
     * 自己捕獲err
     * 注意，這里是調(diào)用generator遍歷器上的throw方法
     * 一個(gè)generator執(zhí)行出錯(cuò)后就不再執(zhí)行，返回{value:undefined, done: true}，故這里調(diào)用next函數(shù)會(huì)在第一個(gè)if結(jié)束
     */

    function onRejected(err) {
      var ret;
      try {
        ret = gen.throw(err);
      } catch (e) {
        return reject(e);
      }
      next(ret);
    }

    /**
     * 首先檢查是否結(jié)束
     * 沒(méi)有結(jié)束就把結(jié)果value轉(zhuǎn)化為Promise類型
     * 轉(zhuǎn)化成功就執(zhí)行Promise，這里是被onFulfilled調(diào)用，現(xiàn)在又反過(guò)去調(diào)用onFulfilled，形成遞歸。
     * 失敗就調(diào)用onRejected函數(shù)
     */

    function next(ret) {
      if (ret.done) return resolve(ret.value);
      var value = toPromise.call(ctx, ret.value);
      if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
      return onRejected(new TypeError("You may only yield a function, promise, generator, array, or object, "
        + "but the following object was passed: "" + String(ret.value) + """));
    }
  });
}

/**
 * Convert a `yield`ed value into a promise.
 *
 * @param {Mixed} obj
 * @return {Promise}
 * @api private
 */

function toPromise(obj) {
  if (!obj) return obj;
  if (isPromise(obj)) return obj;
  if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj);
  if ("function" == typeof obj) return thunkToPromise.call(this, obj);
  if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
  if (isObject(obj)) return objectToPromise.call(this, obj);
  return obj;
}

/**
 * Convert a thunk to a promise.
 *
 * @param {Function}
 * @return {Promise}
 * @api private
 */

function thunkToPromise(fn) {
  var ctx = this;
  return new Promise(function (resolve, reject) {
    fn.call(ctx, function (err, res) {
      if (err) return reject(err);
      if (arguments.length > 2) res = slice.call(arguments, 1);
      resolve(res);
    });
  });
}

/**
 * Convert an array of "yieldables" to a promise.
 * Uses `Promise.all()` internally.
 *
 * @param {Array} obj
 * @return {Promise}
 * @api private
 */

function arrayToPromise(obj) {
  return Promise.all(obj.map(toPromise, this));
}

/**
 * Convert an object of "yieldables" to a promise.
 * Uses `Promise.all()` internally.
 *
 * @param {Object} obj
 * @return {Promise}
 * @api private
 */

function objectToPromise(obj){
  var results = new obj.constructor();
  var keys = Object.keys(obj);
  var promises = [];
  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    var promise = toPromise.call(this, obj[key]);
    if (promise && isPromise(promise)) defer(promise, key);
    else results[key] = obj[key];
  }
  return Promise.all(promises).then(function () {
    return results;
  });

  function defer(promise, key) {
    // predefine the key in the result
    results[key] = undefined;
    promises.push(promise.then(function (res) {
      results[key] = res;
    }));
  }
}

/**
 * Check if `obj` is a promise.
 *
 * @param {Object} obj
 * @return {Boolean}
 * @api private
 */

function isPromise(obj) {
  return "function" == typeof obj.then;
}

/**
 * Check if `obj` is a generator.
 *
 * @param {Mixed} obj
 * @return {Boolean}
 * @api private
 */

function isGenerator(obj) {
  return "function" == typeof obj.next && "function" == typeof obj.throw;
}

/**
 * Check if `obj` is a generator function.
 *
 * @param {Mixed} obj
 * @return {Boolean}
 * @api private
 */
 
function isGeneratorFunction(obj) {
  var constructor = obj.constructor;
  if (!constructor) return false;
  if ("GeneratorFunction" === constructor.name || "GeneratorFunction" === constructor.displayName) return true;
  return isGenerator(constructor.prototype);
}

/**
 * Check for plain object.
 *
 * @param {Mixed} val
 * @return {Boolean}
 * @api private
 */

function isObject(val) {
  return Object == val.constructor;
}