搞定 Koa 之 Node.js generator 与 co

koa 是由 TJ 大神利用 generator 开发的 Web 框架。要理解 koa，首先要先了解 generator 与 co。作为搞定 koa 的第一篇，我们便谈谈这个。文章首发在 boke.io。

系列目录

1. 搞定 koa 之 generator 与 co
2. 搞定 koa 之 co 源码解析

generator 介绍

首先来看一个简单的 generator 函数示例：

function* Gene() {
    yield 1;
    yield 2;
}

var gene = Gene();
console.log(gene.next()); // { value: 1, done: false }
console.log(gene.next()); // { value: 2, done: false }
console.log(gene.next()); // { value: undefined, done: true }

从上面我们可以看到：

• generator 的定义和普通函数类似，只是在 function 后面多了一个 *。
• 调用 generator 和调用函数一样，只是不会立即执行，而是会生成一个对象。
• generator 生成的对象存在一个 next 函数，调用 next 会返回 yield 运算的结果对象，并停止。再次调用会在下一个 yield 处停止。
• 当所有的 yield 被执行完，调用 next 函数会返回 { value: undefined, done: true }。再次调用会报错。

generator 与异步

看完 generator 的介绍，你可能在想这和异步有什么关系？其实，generator 可以帮助我们更好地处理异步操作。

传统异步代码

假设我们需要串行请求两个网页：

var request = require('request');

var a = {};
var b = {};

request('http://www.google.com', function (error, response, body) {
    if (!error && response.statusCode == 200) {
        a.response = response;
        a.body = body;

        request('http://www.yahoo.com', function (error, response, body) {
            if (!error && response.statusCode == 200) {
                b.response = response;
                b.body = body;
            }
        });
    }
});

这种嵌套的回调地狱（callback hell）使得代码难以阅读和维护。

使用 generator 和 co 处理异步

我们可以使用 generator 和 co 来简化异步操作：

const co = require('co');
const request = require('request');

co(function *() {
    var a = yield request('http://google.com');
    var b = yield request('http://yahoo.com');

    console.log(a[0].statusCode); // 打印 Google 的状态码
    console.log(b[0].statusCode); // 打印 Yahoo 的状态码
})();

在这个例子中，co 函数接收一个 generator 函数，并自动管理异步操作。yield 关键字后面的内容必须是一个可以 then 的 Promise 对象或类似的异步函数。co 会处理这些异步操作并按顺序执行。

co 的工作原理

co 的核心逻辑是这样的：

function co(gen) {
    const it = gen();

    return new Promise((resolve, reject) => {
        function step(nextF) {
            let next;
            try {
                next = nextF();
            } catch(e) {
                return reject(e);
            }

            if (next.done) {
                return resolve(next.value);
            }

            Promise.resolve(next.value).then(
                res => step(() => it.next(res)),
                err => step(() => it.throw(err))
            );
        }

        step(() => it.next());
    });
}

这段代码实现了：

• 实例化 generator 并调用 next()。
• 检查是否已经完成 (done)。
• 将 yield 后面的值转换为 Promise，并处理结果。
• 递归调用 step 函数，直到所有 yield 完成。

通过这种方式，我们可以将复杂的异步操作变得像同步代码一样简洁易读。

总结

本文介绍了 generator 的基本概念以及如何利用 generator 和 co 来处理异步操作。希望这些知识能帮助你更好地理解和使用 koa 框架。

参考资料

• 学习 ES6 生成器（Generator）
• 解决回调金字塔! Harmony Generator, yield, ES6, co 框架学习

联系我

• 微博
• GitHub