生成器与流式输出

3 阅读3分钟

一次输出一部分是如何实现的

普通函数的调用逻辑:调用 → 执行 → 返回一个结果 → 结束。

流式场景:输出一部分 → 等一会 → 继续输出。

在没有生成器之前,需要手写迭代器,例如:

function createCounter(max: number) {
  let i = 0;
  return {
    next() {
      if (i < max) return { value: i++, done: false };
      return { value: undefined, done: true };
    },
  };
}

const it = createCounter(3);

while (true) {
  const res = it.next();
  if (res.done) break;
  console.log(res.value);
}

for...of 本质上就是在调用 next 方法,直到 done 为 true。

可迭代也就是一个有 next 方法的对象。

生成器

其实就是迭代器的语法糖,写作:

function* counter(max: number) {
  for (let i = 0; i < max; i++) {
    yield i;
  }
}

const it2 = counter(3);

while (true) {
  const res = it2.next();
  if (res.done) break;
  console.log(res.value);
}

这里调用 counter 并不会执行函数体,只有执行了 next 才会真正执行函数体。如果函数中有一个输出语句,直接执行这个 function* 函数,输出语句将不会执行,直到调用 next 方法。

此外,yield 是暂停点,而不是返回点。如果一个函数 yield 了,相当于函数暂停在这里了,如果继续调用 next,则函数从暂停的位置继续。

和 return 对比:

returnyield
作用结束函数暂停函数
之后不能继续执行函数可以继续执行
次数一次可以多次

yield* 转发

如果有多个生成器函数,一个生成器函数需要另外一个生成器函数的 yield 值,可以直接 yiled* 另外一个生成器函数的调用。

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

function* b() {
  yield 3;
  yield* a();
  yield 4;
}

const it = b();

while (true) {
  const n = it.next();
  if (n.done) break;
  console.log(n.value);
}

这里输出为:

3
1
2
4

yield* 的作用就是直接把两个生成器连接起来,而不是在里面写一个循环。

async function*

异步的生成器。流式数据来的时候是一段一段来的,并且可能会等待一会,这个情况下就需要异步 async,自然也就有了异步的 yield。

async function* counter(n: number) {
  for (let i = 0; i < n; i++) {
    await new Promise((r) => setTimeout(r, 500));
    yield i;
  }
}

for await (const v of counter(3)) {
  console.log(v)
}

消费的时候可以通过 while 或者 for await of,进而实现流式渲染的功能。

More

为什么用 yield* 而不用 await?

因为 await 只对 thenable 有意义,async generator 对象不是 thenable,所以 await 会直接原样返回它,也不会产生任何数据。

为了可以运行迭代器,则需要使用 yield*。

await 一个 async generator 只会拿到生成器对象本身,不会执行它,更不会产出数据。要拿到数据必须迭代它。yield* 做的事是把内层生成器产出的值逐个转发给外层调用方,这样两条流就接成了一条。

yield* 和 yield 有什么区别

yield* 后面跟的是可迭代对象,通常写作 yield* otherGenerator(),但是那是调用后的返回值,而不是函数本身。

对比一下:

写法含义
yield v吐出一个 v,然后暂停
yield* iterable把 iterable 里面的值依次吐出(委托)

为什么推荐 for...await

for await 本质上是一个语法糖,但是 for await 会在提前退出的时候,自动调用迭代器的 return 方法,从而触发生成器的 finally,而手动的 while 循环则不会。

这会直接关系到方法的执行情况,比如:

try {
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    yield value;
  }
} finally {
  reader.releaseLock();
}

如果需要消费别人写的 async generator,优先使用 for await,让 return 和 finally 的逻辑可以正常运行;如果必须手动 next 的话,则退出时需要记得调用 await it.return()。