Koa 中 co = generator + promise

  • Z时代
  • 2024-01-10
  • 分类：综合

理解了 co 的核心代码就理解了 koa 的流程控制

var ctx = this;
var args = slice.call(arguments, 1);

一开始保存上下文，把 arguments 的 length 属性去掉,剩余的参数转数组就是 gen 的参数

再来看 return 的 promise 内的代码

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

先判断 gen 是不是 generator function，如果是就转为 generator，相当于 gen = new gen;

转为 generator 之后就可以调用 gen.next() 了;

onFulfilled();

这是进入循环调用链的入口

function onFulfilled(res) {
  var ret;
  try {
    ret = gen.next(res);
  } catch (e) {
    return reject(e);
  }
  next(ret);
}
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) + '"'));
}

ret 是 gen.next 后的 {value:”done:”} 对象，value 是 yield 后的表达式，done 是执行状态。

判断 ret.done 是否为 true 来确定是否需要再执行下去，为 true 时，说明已经是 generator 的最后一步，promise 转为 resolve，不为 true 时，将 yield 后的表达式转化为 promise。

先判断是否转化为了 promise，转化成功，就通过 value.then(onFulfilled, onRejected) 执行 onFulfilled 或 onRejected，再次调用 next()，实现循环调用。

当 value 不能转为 promise 时，抛出错误，promise 转为 reject，停止继续运行。

下面写一个例子简单分析一下：

var co = require('co');
var fs = require('fs');
function thunkRead(name) {
  return function (cb) {
    fs.readFile(name, function (err, file) {
      cb(err, file);
    });
  }
}
co(function *() {
  var file = yield thunkRead("package.json");
  console.log(file);
  return file;
}).then(function (file) {
  console.log(file);
});

通过上面这段代码来看一下 co 的整个流程

先模拟一个名为 thunkRead 的 thunk 函数，再看 co 里面的代码，co 里面是一个 generator function，gen = gen.apply(ctx, args); 通过这一句转化为了 generator。

再进入 onFulfilled() 函数，第一个 gen.next() 之后 ret 是 { value: [Function], done: false } 将 ret 传入 next() 中，done 为 false，所以 toPromise，value 是 function，所以 thunkToPromise。

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

因为 fn 是 thunk 函数，参数只有一个回调函数，fn.call(ctx, function (err, res) {}); 直接调用 resolve，在上面的例子中是 resolve(file);

然后回到 next() 中，此时已经是一个 promise 对象，调用 value 的 then 方法，onFulfilled 的参数就是 file，再运行 gen.next(file)，将上一步yield的结果 file 传入 generator，因为在例子中最后 return了file, ret 是 { value:<Buffer ...>, done: true } 最后不返回值的话应该是 { value: undefined, done: true } , 再进入到 next() 中， 此时 done 已经为 true，说明已经是 generator 的最后一步，resolve(value);

co 中的代码已经执行结束，因为 co 也是一个 promise，最后 resolve(value)，所有可以在 then 方法中得到这个 value。

补充下 toPromise 支持转化 thunks、array、objects、generators、generator functions。

所以可以 yieldable 的是以下6种：

  • promises

  • thunks (functions)

  • array (parallel execution)

  • objects (parallel execution)

  • generators (delegation)

  • generator functions (delegation)

以上是 Koa 中 co = generator + promise 的全部内容， 来源链接： utcz.com/z/264490.html

回到顶部