JS 生成器 vs. Lua 协程

“协程（coroutine）”于我而言还是比较新的概念，Lua 也是刚接触不久。不过碰巧这段时间我又在看 ES6 生成器的文章：

• 【译】ES6 生成器 - 1. ES6 生成器基础
• 【译】ES6 生成器 - 2. 深入理解 ES6 生成器
• 【译】ES6 生成器 - 3. ES6 生成器异步编程
• 【译】ES6 生成器 - 4. ES6 生成器与并发

然后很自然地发现两者其实是相似的东西。整理、对比的过程，肯定也会加深自己的理解，所以尽管是初学，还是贸然一试了。

JS 生成器

先来看一个简单的例子：

function *g() {
  yield 1
  yield 2
  yield 3
}

通过 function* 声明了一个生成器函数，这是 ES6/ES2015 引入的新的函数类型，也是下面主要分析的对象。

可以看到，函数体内还有新的 yield 关键字。yield 这里在函数执行时会产生“中断”，而中断时函数的执行环境（变量等）会被保存下来，然后在某个时刻，可以返回中断的位置继续执行函数，同时执行环境被还原。这是我理解的生成器函数的主要特性。

也就是说，和一般的函数不同，生成器函数的执行过程可能是这样的：

• 开始执行
• 暂停
• 继续
• 暂停
• 继续
• ...
• 执行结束

而且暂停和继续之间，其他的代码可以获得控制权进行执行，并且决定在什么时候继续生成器函数的执行，甚至可以永远不继续执行生成器函数。

我们来运行一个完整的示例，看下生成器函数的用法：

var o = g()
console.log(o.next()) // {value: 1, done: false}
console.log(o.next()) // {value: 2, done: false}
console.log(o.next()) // {value: 3, done: false}
console.log(o.next()) // {value: undefined, done: true}

与普通函数不同，调用生成器函数并不是真正执行了函数，而是返回了一个“生成器对象”。从这一点上来看，生成器函数有点类似“构造函数”的感觉，每次调用返回一个新的对象。

当然，这个新的对象也是比较特殊的，它是一个迭代器对象，遵循“iterator”协议。从迭代的角度，也可以称之为“迭代器对象”。

iterator 协议也是 ES6 新增的，它要求支持该协议（或者说接口吧，虽然 JS 中并没有接口）的对象提供一个 next() 方法，每次调用时可以返回一个结果对象。这个迭代结果对象包含 value 和 done 两个属性。在较新版本的 Chrome 控制台执行下示例代码，可以看到，value 是返回的值，done 表示迭代是否执行完成。

看到这里，貌似生成器的确和其名字一样，可以生成一些值，只不过这些值是断断续续地返回的，需要其他的代码主动去获取。基于这些，我们可以做一个能够持续不断返回数据的生成器函数：

function *num() {
  var i = 0
  while (true) {
    yield i++
  }
}

有点暴力，不过的确可行：

var n = num()
console.log(n.next()) // {value: 0, done: false}
console.log(n.next()) // {value: 1, done: false}
console.log(n.next()) // {value: 2, done: false}

可以一直调用 n.next() 下去，和前面的 *g() 不同，这个生成器函数貌似不会主动结束。

ES6 还引入了 for ... of 语句，专门用于迭代，例如，可以这样：

for (var i of g()) {
  console.log(i)
}

for (var n of num()) {
  if (n < 10) {
    console.log(n)
  } else {
    break
  }
}

这个也很容易理解，不多说了。

不过，这还不是有关生成器的全部，如果仅仅是这样，那和后面要介绍的 Lua 的协程的区别就太大了，比人家的能力差得太多。

生成器还支持在生成器函数内外进行数据传递，来看一个例子：

function *query(name) {
  var age = yield getAgeByName(name)
  console.log('name: `' + name + '` age: ' + age)
}

我们把生成器函数 *foo() 作为普通函数来看待，它封装了一段的逻辑。在运行时，外部传入一个名字（name），通过调用 getAgeByName() 来获得名字对应的年龄，然后打印出来。

我们假设 getAgeByName() 是这样的：

function getAgeByName(name) {
  var people = [{
    name: 'luobo',
    age: 18
  }, {
    name: 'tang',
    age: 20
  }]
 
  var person = people.find(p => p.name === name)
  return person.age
}

由于生成器函数与普通函数的执行过程不同，我们定义一个执行生成器函数的函数：

function run(g, arg) {
  var o = g(arg)

  next()

  function next() {
    var result = o.next(arg)
    arg = result.value
    if (!result.done) {
      next()
    }
  }
}

函数 run() 用于生成器函数 g，可以传入一个初始参数 arg，之后每次调用生成器对象的 next() 时，会将上一次调用的返回值传入。

yield 暂停生成器函数执行时，会将一个值返回到生成器外部，而外部程序在调用生成器对象的 next() 方法时可以传入一个参数，这个参数的值会作为 yield 表达式的值使用，然后继续执行生成器函数。

下面我们来实际执行一下上面的 *foo()：

run(query, 'luobo') // name: `luobo` age: 18
run(query, 'tang') // name: `tang` age: 20

好像没什么了不起，而且本来很简单的过程，使用了生成器函数好像还有点复杂了。

还是上面的例子，如果我们改变下 getAgeByName() 函数的实现：

function getAgeByName(name) {
  return fetch('/person?name=' + name).then(res => res.json().age)
}

现在根据名字查找年龄的过程是异步的了，需要向服务器获取数据。如果是通过普通函数实现 *query() 的逻辑，那我们需要修改函数的实现，因为同步获取数据和异步是不同的编程方式，通常需要改用回调函数。

不过生成器本身的执行就是“异步”的，而且生成器支持数据传递。所以，借助这个特性，我们其实可以不必修改 *query() 的逻辑，而是在 run() 上做一下处理：

function run(g, arg) {
  var o = g(arg)

  next()

  function next() {
    var result = o.next(arg)
    arg = result.value
    if (!result.done) {
      // 返回值可能是 Promise 对象
      if (arg && typeof arg.then === 'function') {
        arg.then(val => {
          arg = val
          next()
        })
      } else {
        next()
      }
    }
  }
}

将对异步状态的处理拆分到了与逻辑无关的控制函数 run() 中，而具体的逻辑部分（*query()）不需要修改代码。

看到这里，是不是有点意思了？当然，或许你早就知道这些了。

稍微总结一下 JS 生成器吧。

JS 生成器除了作为“生成器”来使用，还可以作为一种改善代码编写方式的技术，它可以使得我们能够写出类似“同步”执行的异步代码，这样的代码毕竟更易读和维护。

有关生成器的特性，其实还有很多，本文前面列出的四篇文章中有比较全面的介绍，这里不再赘述。

下面，我们来看 Lua 中的协程。

Lua 协程

先看一个例子：

co = coroutine.create(function ()
    coroutine.yield(1)
    coroutine.yield(2)
    coroutine.yield(3)
  end)

print(coroutine.resume(co)) --> true    1
print(coroutine.resume(co)) --> true    2
print(coroutine.resume(co)) --> true    3
print(coroutine.resume(co)) --> true
print(coroutine.resume(co)) --> false   cannot resume dead coroutine

这个例子和 JS 生成器一节的第一个例子类似，不过有一些区别：

• Lua 的协程通过 coroutine 库来创建，coroutine.create() 接收的是普通函数，而 JS 则是新增了生成器函数这一新的函数类型
• Lua 的协程对应的是 thread 类型的值，JS 的生成器函数调用后返回的是迭代器对象
• Lua 的协程通过 coroutine.resume(co) 的模式来执行，JS 则是利用迭代器接口的 next() 方法来执行
• Lua 的协程内部通过 coroutine.yield() 来产生中断，JS 则是通过 yield 关键字
• Lua 的协程中断返回的是一组值，第一个值表示是否执行成功，后续的值为传递的数据，JS 函数只能返回一个值，所以是通过对象来传递状态和返回值的
• Lua 的协程结束执行后再次调用，会产生异常，JS 不会

Lua 的 for ... in 也可以对协程进行迭代，与 JS 类似：

co = coroutine.wrap(function ()
    coroutine.yield(1)
    coroutine.yield(2)
    coroutine.yield(3)
  end)

for i in co do
  print(i)
end

不过区别在于，由于 Lua 的协程对应的是 thread 类型的值，而并非是迭代器，所以这里通过 coroutine.wrap() 将协程包装为迭代器返回。

Lua 的协程也支持进行数据传递，所以在 JS 部分介绍的所谓“同步”的异步模式，在 Lua 中也是可以实现的。

不过还是可以看出，Lua 的协程的确是“协程”，并不是为了实现“生成器”而设计，只不过“顺便”能够支持作为生成器来使用而已。而 JS 生成器则是作为生成器设计，生成器函数调用后返回的就是一个迭代器，而非像 Lua 那样的一个特殊类型的值（thread）。不过也可以利用 JS 生成器内部的“pause-resume”机制实现一些编程技巧，这就有点协程的味道了。

更深入的分析 Lua 的协程和 JS 生成器的区别，需要对 Lua 的协程有更深入的理解，不过我还没有这样的能力。所以，抱歉，目前只能在表面上做些文章。

总结

协程（coroutine）是一个重要的编程技术，在许多编程语言中都有体现。

Lua 中的协程，据相关文档介绍，是具有较完整的相关特性的实现，而且在 Lua 编程中有广泛的应用，是重要的技术。

JS 的生成器，在 ES6 中才引入，虽然叫做生成器，不过的确有些“协程”的特性，这也是为什么可以基于这些特性构建新的异步编程解决方案，因为生成器函数的执行具有“暂停-继续”的特性。显然协程这一重要的编程技术被引入到了 JS 中。

从更高的层面来讲，协程和多线程是两种解决“多任务”编程的技术。多线程使得同一时刻可以有多个线程在执行，不过需要在多个线程间协调资源，因为多个线程的执行进度是“不可控”的。而协程则避免了多线程的问题，同一时刻实质上只有一个“线程”在执行，所以不会存在资源“抢占”的问题。

不过在 JS 领域，貌似不存在技术选择的困难，因为 JS 目前还是“单线程”的，所以引入协程也是很自然的选择吧。

如有错漏，欢迎指正。

感谢阅读！

更多参考资料：

• Coroutines - Programming in Lua
• Generator - MDN
• Iterators and generators - MDN
• Using Fetch - MDN