Promise學習筆記——co.js

大神的自我修養 co.js 的學習

最近在項目過程中涉及大量異步流程處理，其中有使用各種流程控制庫，大家用的最多的 async，號稱promise性能超原生的 bluebird，還有tj大神的co.js等。可以說是相當多了，於是空暇期間來整理一下promise的學習。

今天來看的就是TJ大神的非常精煉的 co.js 。

具體的介紹就不多說了。要注意的一點就是，[email protected]之前返回的是一個trunk函數，現在[email protected]支持promise，現在co()會返回一個promise。

先看用法

yieldable支持

co最方便的操作也就是yield的支持，現在支持yield的對象有：

• promises
• thunks (functions)
• array (parallel execution)
• objects (parallel execution)
• generators (delegation)
• generator functions (delegation)

下文在源碼裏有體現。

一個官網的小例子

var co = require('co');

co(function *(){
  // 執行promise
  var result = yield Promise.resolve(true);
}).catch(onerror);

co(function *(){
  // 並行執行多個promise
  var a = Promise.resolve(1);
  var b = Promise.resolve(2);
  var c = Promise.resolve(3);
  var res = yield [a, b, c];
  console.log(res);
  // => [1, 2, 3]
}).catch(onerror);

// 錯誤捕捉
co(function *(){
  try {
    yield Promise.reject(new Error('boom'));
  } catch (err) {
    console.error(err.message); // "boom"
 }
}).catch(onerror);

function onerror(err) {
  console.error(err.stack);
}

// 將一個generator函數轉換成返回一個promise函數的方法
var fn = co.wrap(function* (val) {
  return yield Promise.resolve(val);
});

fn(true).then(function (val) {

});

看源碼

wrap 函數的實現

大神寫的代碼就是十分的精煉，wrap 函數的實現也只是7行代碼而已。

其實有兩點需要注意的，就是：

1. 沒有寫在原型鏈上而是作爲一個私有方法是爲了避免每次執行co()的時候生成一個新的wrap方法，這個方法顯然沒必要。
2. 關鍵在於返回了一個co(),因爲co()會 return 一個 promise，即生成一個新的promise。同時利用 call 和 apply 改變了 this 的指向，指向 co 。

並行多個promise

其實 co 方法的主體不用細看，基本就是按照 es6 promise 的一種重寫。這裏需要注意的一點就是並行支持promise。即，當 yield 一個 object 或者 array 的時候，並行執行多個 promise。

一開始當我聽到並行的時候，是有點懵的，但看到源碼的時候發現沒有想得那麼複雜，其實就是 promise 的原生方法的功勞：promise.all(),可以往下看。。。

這裏的 toPromise() 是在 next 方法的實現中執行的，關鍵的代碼就兩句：

var value = toPromise.call(ctx, ret.value);
if (value && isPromise(value)) return value.then(onFulfilled, onRejected);

然後，就是 arrayToPromise 和 objectToPromise 兩個方法的實現：

就是這麼簡單……

廬山真面目，真正的源碼

var slice = Array.prototype.slice;

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

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

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

  return new Promise(function(resolve, reject) {
    if (typeof gen === 'function') gen = gen.apply(ctx, args);
    if (!gen || typeof gen.next !== 'function') return resolve(gen);

    onFulfilled();

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

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

    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) + '"'));
    }
  });
}

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;
}

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);
    });
  });
}


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


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;
    }));
  }
}

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


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


function isGeneratorFunction(obj) {
  var constructor = obj.constructor;
  if (!constructor) return false;
  if ('GeneratorFunction' === constructor.name || 'GeneratorFunction' === constructor.displayName) return true;
  return isGenerator(constructor.prototype);
}


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