1. 程式人生 > >Promise學習筆記——co.js

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

然後,就是 arrayToPromiseobjectToPromise 兩個方法的實現:

就是這麼簡單……

廬山真面目,真正的原始碼


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