别一次全算完:JavaScript 生成器与迭代器 function*、yield,一次只给一个值
数组得一次全算好,生成器一次只给一个值,要的时候再算。本文按 MDN 的《Iterators and generators》《function*》《Generator》三篇官方文档讲清楚:next() 协议、function* 与 yield、for...of 消费、Symbol.iterator、yield* 委托、next(x) 往里传值、throw() 与 return(),以及什么时候该用生成器,另附虚构咖啡馆点单页一个月 100 次生成器翻车的分布。

先把这篇的边界说清楚。站里已经有不少 JavaScript 基础指南:循环指南讲过 for、while、for...of 怎么重复做一件事,函数指南讲过怎么写函数,Promise 与 async 讲过怎么等异步结果,数组方法讲过怎么摆弄列表,Map 与 Set 讲过怎么按名找东西、怎么去重,对象与解构讲过怎么拆数据。这篇不讲它们,只讲一件事:一次只给一个值、要的时候再算的机制,也就是迭代器与生成器。下面用到的“青石咖啡馆”还是那个虚构的练手项目:一个帮街边咖啡馆做点单的网页小工具。之前几篇讲的是它的点单页怎么做决定、怎么循环、怎么取数,这回讲的是它的出单号:取餐号一个一个往外发,顾客叫到号再来取,不用一开始就把全天的号都算好。本文所有以它为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。所有关于迭代器与生成器的语法与行为,都来自 MDN 的《Iterators and generators》《function*》《Generator》三篇官方文档,来源见每篇的 meta 信息与 evidence 记录。读完这篇,你应该能做到四件事:会读懂 next() 返回的 { value, done }、会写 function* 与 yield、会用 for...of 与展开语法消费生成器、知道什么时候该用生成器、什么时候直接用数组就够了。循环指南里明确留出没讲的生成器,就是这篇要讲的。
第一步:先看问题,数组得一次全算好
点单页要给今天的订单排取餐号,1 号、2 号、3 号一直排下去。如果用数组写,就得先把号全算出来放进数组:今天有 200 单,就先算 200 个号;明天有 500 单,就先算 500 个。号还没人来取,算的工作已经全做完了。更麻烦的是“不知道有多少”的时候:取餐号理论上可以一直发下去,数组装不下“无限多个”。MDN 在讲迭代器时开篇就点破了这一点:数组必须整个分配好,但迭代器是按需消费的,只在需要的时候才算下一个。正因为这样,迭代器能表达无限长的序列,比如从 0 到无穷大的整数,而数组不行。迭代器这个词听着大,其实意思很小:一个对象,只要它有个 next() 方法,每次调用返回下一个值,外加一个“完了没有”的标记,它就是迭代器。生成器是写迭代器的省力办法:不用自己手写状态机,写一个带星号的函数,里面用 yield 一个一个往外吐值,JavaScript 帮你把状态记下来。这一节先记住这个分工:迭代器是规矩,生成器是按规矩办事的省力写法。
第二步:迭代器协议,next() 每次给 { value, done }
所谓迭代器协议,就是一个约定:对象上有个 next() 方法,每次调用返回一个带两个属性的对象:value 是序列里的下一个值,done 是个布尔值,告诉你最后一个值是不是已经被取完了。如果 value 和 done 一起出现,value 是迭代器结束时返回的值。MDN 的例子是手写一个取数范围的迭代器:
function makeRangeIterator(start = 0, end = Infinity, step = 1) {
let nextIndex = start;
let iterationCount = 0;
const rangeIterator = {
next() {
let result;
if (nextIndex < end) {
result = { value: nextIndex, done: false };
nextIndex += step;
iterationCount++;
return result;
}
return { value: iterationCount, done: true };
},
};
return rangeIterator;
}
const iter = makeRangeIterator(1, 10, 2);
let result = iter.next();
while (!result.done) {
console.log(result.value); // 1 3 5 7 9
result = iter.next();
}
console.log("Iterated over sequence of size:", result.value); // [5 numbers returned, that took interval in between: 0 to 10]
从 1 开始、不到 10、步长 2,依次得 1、3、5、7、9,一共 5 个数,结束时返回的 value 是 5,也就是序列的长度。注意两点。第一,迭代器是“消耗品”:取过的数不会再给第二遍,跑完了就完了,再调 next() 也只会一直返回 { done: true }。MDN 的原话是“遍历一个迭代器就是在消耗它,因为一般只能遍历一次”。第二,自己手写迭代器得小心维护内部状态:nextIndex 走到哪了、数了几个数,全得自己记,写错一步就全乱。MDN 紧接着就说,虽然手写迭代器有用,但要小心维护状态,生成器函数是更强大的替代品。下面一节就讲它。
第三步:function* 与 yield,调用时不跑,next() 才跑一段
生成器函数用 function* 写,星号是它和普通函数的区别。关键行为只有一句话:调用它的时候,函数体一行也不执行,只返回一个特殊的迭代器,叫 Generator;等你调这个 Generator 的 next(),函数体才从头跑到第一个 yield,然后停住,把 yield 后面的值交出来;再调一次 next(),就从上次停住的地方继续跑,到下一个 yield 再停。MDN 的例子:
function* generator(i) {
yield i;
yield i + 10;
}
const gen = generator(10);
console.log(gen.next().value);
// Expected output: 10
console.log(gen.next().value);
// Expected output: 20
generator(10) 调用时什么也没算,第一个 next() 才跑到第一个 yield,给出 10;第二个 next() 跑到第二个 yield,给出 20;第三个 next() 时函数体已经跑完,得 { value: undefined, done: true }。同一个生成器函数可以调很多次,每次都返回一个新的 Generator,各个 Generator 各跑各的、互不干扰;但每个 Generator 只能被遍历一次,这一点和上一节的迭代器一样。还有两个收尾规则。第一,函数体里写了 return,next() 会返回 { value: 返回的值, done: true },return 后面的 yield 再也跑不到。MDN 的例子是 yieldAndReturn:第一个 next() 得 { value: "Y", done: false },第二个得 { value: "R", done: true },第三个得 { value: undefined, done: true },那个 "unreachable" 的 yield 永远到不了。第二,函数体里扔了没接住的错,next() 会把这个错抛出来,生成器随之结束,之后的 next() 都只返回 { value: undefined, done: true }。我的判断是:把生成器函数想成“可以暂停的函数”,yield 就是暂停键,next() 就是继续键,暂停几次、每次吐什么,全由 yield 的位置决定。
第四步:for...of 消费生成器,无限的也得配 break
手写 next() 循环太啰嗦,日常用 for...of 来消费生成器:for...of 会自动调 next(),直到 done 是 true 才停,return 的那个值不会被 for...of 收进循环体。MDN 的无限取号器例子最能说明生成器的用处:
function* idMaker() {
let index = 0;
while (true) {
yield index++;
}
}
const gen = idMaker();
console.log(gen.next().value); // 0
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
console.log(gen.next().value); // 3
// …
while (true) 在普通函数里是死循环,在生成器函数里不是:每次 yield 都停住等下一次 next(),所以 0、1、2、3 一个一个往外给,永远给不完,也永远不会卡死。咖啡馆的取餐号就是这个写法:function* ticketNumbers() 从 1 开始一直往下发,叫到几号就取几个,不用提前算好全天的号。MDN 还有一个算 2 的次方的例子,配 break 用:
function* powers(n) {
// Endless loop to generate
for (let current = n; ; current *= n) {
yield current;
}
}
for (const power of powers(2)) {
// Controlling generator
if (power > 32) {
break;
}
console.log(power);
// 2
// 4
// 8
// 16
// 32
}
2、4、8、16、32 依次出来,到了 64 就 break 停住。无限生成器必须配一个停下来的条件,break 是最常用的一个;忘了写停的条件,for...of 会一直跑下去,页面就卡住了。还有一个细节:for...of 拿不到生成器 return 的那个值,循环结束时 return 的值就丢了,想要它就得自己调 next() 去读最后一次返回的对象。
第五步:可迭代对象与 Symbol.iterator,普通对象为什么不能 for...of
迭代器是“一个一个给值”的对象,可迭代对象是“知道怎么一个一个给值”的对象。一个对象是可迭代的,当且仅当它实现了 [Symbol.iterator]() 方法,也就是它(或者它原型链上的某个对象)有个以 Symbol.iterator 为键的属性。数组、Map、Set、字符串这些内置类型都是可迭代的,因为它们的原型对象上都有这个方法;普通对象不是,所以直接 for...of 一个普通对象会报错。MDN 的例子是自己造一个可迭代对象:
const myIterable = {
*[Symbol.iterator]() {
yield 1;
yield 2;
yield 3;
},
};
for (const value of myIterable) {
console.log(value);
}
// 1
// 2
// 3
[...myIterable]; // [1, 2, 3]
方法名前面那个星号的意思是“这是一个生成器方法”,方法体里 yield 什么,for...of 就收到什么。展开语法 [...] 也一样,它要的也是可迭代对象,所以 [...myIterable] 得 [1, 2, 3]。生成器本身也是可迭代的,但它的 [Symbol.iterator]() 返回的是它自己,所以只能跑一遍:MDN 的例子里,makeIterator 产出 1、2,iter[Symbol.iterator]() === iter 是 true,第一遍 for...of 得 1、2,第二遍就什么都没有了。想让它能跑多遍,就得把 [Symbol.iterator] 换成一个每次返回新生成器的方法,MDN 的例子换完之后再跑得的是 2、1。咖啡馆的例子:订单列表用生成器分页,每页 3 单,10 单分 4 页:[1, 2, 3]、[4, 5, 6]、[7, 8, 9]、[10],页数不用提前算,for...of 跑到没页了自己停。我的判断是:判断一个东西能不能 for...of,不用背清单,只问一句“它有没有 [Symbol.iterator]()”,有就能,没有就不能,数组、字符串、Map、Set 都有,普通对象没有。
第六步:yield* 委托,把另一个生成器接进来
一个生成器想把活交给另一个生成器干,用 yield*,星号不能省。MDN 的例子是两层生成器接力:
function* anotherGenerator(i) {
yield i + 1;
yield i + 2;
yield i + 3;
}
function* generator(i) {
yield i;
yield* anotherGenerator(i);
yield i + 10;
}
const gen = generator(10);
console.log(gen.next().value); // 10
console.log(gen.next().value); // 11
console.log(gen.next().value); // 12
console.log(gen.next().value); // 13
console.log(gen.next().value); // 20
先自己吐 10,再把 11、12、13 交给 anotherGenerator 吐,最后自己吐 20。yield* 后面也可以直接跟数组这类可迭代对象:yield* ["a", "b", "c"] 会依次吐出 "a"、"b"、"c",第一个 next() 得 { value: "a", done: false }。最容易踩的坑是把星号写漏:yield anotherGenerator(i) 不带星号,吐出来的是一个 Generator 对象本身,而不是它里面的值,收到的人拿到的是一个对象,不是 11、12、13。咖啡馆的例子:出餐分两条线,热饮一队、冷饮一队,主生成器先 yield* 热饮的,再 yield* 冷饮的,取餐屏上就是一条完整的出餐顺序,不用把两队拼成一个大数组再循环。我的判断是:看到 yield* 就读成“把后面这个可迭代对象的每一项依次交出来”,看到 yield 就读成“交出这一个东西”,两个符号差一个星号,意思差了一整层。
第七步:next(x) 往里传值,第一次传的值会被忽略
next() 不光能往外取值,还能往里传值:传给 next() 的值,会成为生成器里当前那个 yield 表达式的值。MDN 的原话是“next() 方法也接受一个值,这个值可以用来修改生成器的内部状态,传给 next() 的值会被 yield 收到”。但有一条铁规则:第一次调用 next() 时传的值永远被忽略,因为第一次调用时函数体还没跑到任何一个 yield,根本没有人在等这个值。MDN 的斐波那契例子把这套机制用到了极致:
function* fibonacci() {
let current = 0;
let next = 1;
while (true) {
const reset = yield current;
[current, next] = [next, next + current];
if (reset) {
current = 0;
next = 1;
}
}
}
const sequence = fibonacci();
console.log(sequence.next().value); // 0
console.log(sequence.next().value); // 1
console.log(sequence.next().value); // 1
console.log(sequence.next().value); // 2
console.log(sequence.next().value); // 3
console.log(sequence.next().value); // 5
console.log(sequence.next().value); // 8
console.log(sequence.next(true).value); // 0
console.log(sequence.next().value); // 1
console.log(sequence.next().value); // 1
console.log(sequence.next().value); // 2
0、1、1、2、3、5、8 依次出来,调一次 next(true),生成器从头开始,0、1、1、2 又来一遍。MDN 还有一个更直白的例子 logGenerator:函数体里每到一个 yield 就打印一句话,next("pretzel") 让它打印 "1 pretzel",next("california") 打印 "2 california",next("mayonnaise") 打印 "3 mayonnaise",传进去的值原样出现在打印里。咖啡馆里这个机制用不上太多,我的判断是:新手先不用惦记往里传值,把“yield 往外吐、next() 往里递”当成进阶用法,知道第一次传值会被忽略、别在第一次 next() 里传关键参数,就够了。真正常用的是不传值的 next() 和 for...of。
第八步:throw() 与 return(),从外面结束一个生成器
生成器除了 next(),还有两个方法可以从外面干预它。throw() 的意思是“假装在生成器当前停住的地方扔了个错”:如果生成器函数体里有 try...catch 接住了,catch 里可以继续 yield 值;如果没接住,错会顺着这次 throw() 调用抛出来,生成器随之结束,之后再调 next() 只会得 { value: undefined, done: true }。return() 的意思是“假装在停住的地方写了个 return”:生成器立刻结束,这次 return() 调用返回 { value: 你传的值, done: true },而且函数体里的 finally 一定会跑,可以用来做清理,比如关掉打开的资源。MDN 的原话是:return() 方法返回给定的值并结束生成器本身;配合 try...finally 使用时,能让生成器在结束前执行清理任务。咖啡馆的例子:取餐屏的生成器正在一个一个吐号,店打烊了要提前结束,调 return() 就行,finally 里的“关闭取餐屏”一定会跑,不会漏。还有两个相关的硬事实。第一,生成器函数没有箭头函数的写法,function* 就是唯一的写法。第二,生成器函数不能拿来 new,new f() 会扔 TypeError,说它不是构造器。调用生成器函数得的是 Generator 对象,不是实例,这一点别搞混。
第九步:什么时候用生成器,什么时候别用
生成器最适合三件事。第一,按需算值:数据量大或者无限长,一次只算一个,内存里永远只留当前这一个,比如取餐号、分页、逐行读大文件。第二,把复杂循环的状态收进一个函数:手写迭代器要自己维护下标和计数,生成器函数里写个 for 循环加几个 yield 就完了,状态由函数自己记着。第三,定义可迭代对象:想让一个自定义对象能 for...of、能展开,在它上面挂一个 *[Symbol.iterator]() 方法,里面 yield 几次就完事,第五步的例子就是这样。不适合用生成器的情况也要记住:列表本来就不大、一次全算好也没什么成本,直接用数组和循环,别为了用生成器而用;异步流程现在有更简单的 async 函数和 Promise 模型,MDN 在 function* 页面明说,生成器以前是用来躲回调地狱的,如今这个用途已被 async 函数和 Promise 解决,生成器仍然有用的地方是定义迭代器这类任务。这篇和 Promise 与 async 指南的划界就在这里:那边讲“怎么等一个异步结果”,这边讲“怎么一次只给一个值”,两件事不重叠。还有一个判断标准:如果你发现自己在生成器里写 yield 只是为了把数组里的东西一个一个吐出来,停下来想想,直接 for...of 数组是不是更简单,十有八九是。
第十步:七个坑与一张检查清单
最后是七个新手最常踩的坑,也是下图的数据来源。第一,调用生成器函数以为代码立刻跑了,其实它一行也没跑,第一次 next() 才开始。第二,同一个生成器用了第二遍,以为能重跑,其实它只能跑一遍,想重跑得重新调生成器函数拿个新的。第三,忘了写 yield,函数一次跑完只给一个 return 值,白写了个星号。第四,next() 的返回值只取 .value,忘了看 done,生成器跑完了还在读,把 undefined 当成真值用了。第五,第一次 next() 传值,以为能传进去,其实第一次传的值永远被忽略。第六,yield* 忘写星号,只产出一个生成器对象,收到的人拿到的是对象不是值。第七,生成器用完了还在 next(),以为会报错,其实它只会安静地一直返回 { value: undefined, done: true }。检查清单照着过一遍:生成器函数是不是写了星号、有没有 yield;消费它用的是 for...of 还是手写 next() 循环,for...of 的话 return 值是不是丢了也无所谓;无限生成器有没有 break 或者别的停下来的条件;[Symbol.iterator] 返回的是自己还是新生成器,只能跑一遍的东西有没有被跑第二遍;next() 传值是不是第一次就传了。
再补一个容易忽略的点:生成器 return 的值不是白给的,它只有手写 next() 循环才拿得到。for...of 跑到 done 是 true 就停,停的时候那个 return 值已经被它丢掉了,你在循环体里永远看不见它。手写范围迭代器的例子里,最后一次 next() 返回的 value 是 5,也就是序列的长度,那个 5 只有手写 while 循环才读得到,换成 for...of 就没了。我的判断是:return 值只适合放“顺带告诉调用方”的信息,比如一共吐了几个值,调用方想知道就手写循环去读;如果 return 的值是正经要用的数据,别放在 return 里,老老实实再 yield 一次,让 for...of 也能收到。还有一个配套的细节:生成器跑完之后再调 next(),得的永远是 { value: undefined, done: true },不是报错也不是上一次的值,写循环判断时别指望它会变。
上图是虚构的青石咖啡馆点单页一个月里 100 次生成器翻车的原因分布:调用生成器函数以为代码立刻跑了 24 次;同一个生成器用了第二遍,以为能重跑 18 次;忘了写 yield,函数一次跑完只给一个值 16 次;next() 返回值只取 .value,忘了 done 12 次;第一次 next() 传值,以为能传进去 11 次;yield* 忘写星号,只产出一个生成器对象 10 次;生成器用完还在 next(),以为会报错 9 次。24 + 18 + 16 + 12 + 11 + 10 + 9 = 100,账是平的。排前三位的错加起来占了快六成,都是“把生成器当成普通函数”的误会:普通函数调了就跑、跑完能再调,生成器调了不跑、跑完不能再跑。图里每一类都能在正文里找到对应的步骤:第一类见第三步,第二类见第三步和第五步,第三类见第三步,第四类见第二步,第五类见第七步,第六类见第六步,第七类见第三步和第八步。下次生成器行为不对,先按这个顺序查:先看是不是调完没 next(),再看是不是同一个生成器跑了第二遍,大概率两步就能定位到。
回头看这篇的四件事:next() 每次返回 { value, done },done 是 true 就是完了;function* 调了不跑,yield 是暂停键,next() 是继续键;for...of 和展开语法会自动消费生成器,但 return 的值和第二遍都拿不到;生成器适合按需算值、无限序列和自定义可迭代对象,简单列表直接用数组,别硬套。循环指南里的 for...of 在这里换了个角色:那边它是遍历数组的主力,这边它是消费生成器的主力,语法还是那个语法,变的只是数据源。写完这篇就去把点单页的取餐号改成生成器:号一个一个发,叫到几号算几号,不用提前算好全天的号,代码还比数组版短。
评论 (0)
原始来源
相关文章
主线程又要画页面又要算账,一算就卡。Worker 是另一条线程、另一个全局上下文,两边只靠消息传话。本文按 MDN 的《Using Web Workers》与《Worker》两篇官方文档讲清楚:new Worker、postMessage 与 onmessage、结构化克隆的复制语义、Worker 里能与不能、onerror 与 terminate()、SharedWorker、Transferable 零拷贝,另附虚构咖啡馆点单页一个月 100 次 Worker 翻车的分布。
setTimeout 管一次,setInterval 管反复,但 delay 只保证“最少等这么久”:0 也不立刻、后台标签页还会更晚、超过 2147483647 会溢出。本文按 MDN 的 setTimeout 与 setInterval 两篇官方文档讲清楚:异步返回、传参、delay 的数字规矩、嵌套 4 毫秒、clearTimeout 与 clearInterval、递归 setTimeout、this 丢失与字符串参数,另附虚构咖啡馆点单页一个月 100 次定时器翻车的分布。
数据里缺一层,整张点单页就可能白屏。本文按 MDN 的《Optional chaining》《Nullish coalescing》《Logical nullish assignment》三篇官方文档讲清楚:?. 三种写法与短路、可选调用与方括号取值、?? 与 || 在 0 和空字符串上的差别、?. 与 ?? 联手、?? 不能和 ||、&& 直接混写、??= 补默认值,另附虚构咖啡馆点单页一个月 100 次取不到值的分布。