JavaScript 生成器非常酷。它们就像常规函数，但具有超能力。我最近经常使用它们，我不得不说，它们改变了我对代码中控制流的思考方式。
让我们从基础开始。生成器是一个可以暂停和恢复的函数。它使用 function* 语法和yield 关键字。这是一个简单的例子：
function* counttothree() { yield 1; yield 2; yield 3; } const counter = counttothree(); console.log(counter.next().value); // 1 console.log(counter.next().value); // 2 console.log(counter.next().value); // 3
看看我们如何一次单步执行一个yield函数？这就是生成器的魔力。
但是生成器的功能远不止计数。它们非常适合创建自定义迭代器。假设您要生成斐波那契数列：
function* fibonacci() { let [prev, curr] = [0, 1]; while (true) { yield curr; [prev, curr] = [curr, prev + curr]; } } const fib = fibonacci(); for (let i = 0; i < 10; i++) { console.log(fib.next().value); }
这个生成器将永远持续生成斐波那契数。这是一个无限序列，但我们只计算我们需要的值。
这给我们带来了生成器最酷的事情之一：惰性求值。他们仅在我们要求时计算值。这对于大型数据集或复杂的计算来说非常高效。
立即学习“Java免费学习笔记（深入）”；
让我们看一个更实际的例子。假设您正在为大型数据集构建分页系统：
function* paginate(items, pagesize) { for (let i = 0; i < items.length; i += pagesize) { yield items.slice(i, i + pagesize); } } const allitems = array.from({ length: 100 }, (_, i) => i + 1); const pagesize = 10; const pages = paginate(allitems, pagesize); console.log(pages.next().value); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] console.log(pages.next().value); // [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
这个生成器让我们可以根据需要获取数据页，而无需立即将所有内容加载到内存中。
生成器在异步编程方面也很出色。它们可以使异步代码看起来和行为更像同步代码。这是使用 co 库的示例：
const co = require('co'); function* fetchuserdata() { const user = yield fetchuser(); const posts = yield fetchposts(user.id); const comments = yield fetchcomments(posts[0].id); return { user, posts, comments }; } co(fetchuserdata).then(result => { console.log(result); }).catch(error => { console.error(error); });
这段代码看起来是同步的，但实际上它进行了三个异步调用。生成器在每次收益处暂停，直到承诺解决。
生成器还可以用于协作多任务处理。您可以创建多个生成器并在它们之间切换，模拟并发执行：
function* task1() { yield 'start task 1'; yield 'middle of task 1'; yield 'end task 1'; } function* task2() { yield 'start task 2'; yield 'middle of task 2'; yield 'end task 2'; } function run(tasks) { const iterations = tasks.map(task => task()); while (iterations.length) { const [first, ...rest] = iterations; const { value, done } = first.next(); if (!done) { console.log(value); iterations.push(first); } iterations.unshift(...rest); } } run([task1, task2]);
此代码在两个任务之间交替，一次运行每个步骤。
生成器也非常适合创建状态机。每个收益可以代表不同的状态：
function* trafficlight() { while (true) { yield 'red'; yield 'green'; yield 'yellow'; } } const light = trafficlight(); console.log(light.next().value); // red console.log(light.next().value); // green console.log(light.next().value); // yellow console.log(light.next().value); // red
此交通灯将无限期地循环穿过其状态。
现在，我们来谈谈一些更高级的技术。生成器委托允许您屈服于另一个生成器：
function* innergenerator() { yield 'inner 1'; yield 'inner 2'; } function* outergenerator() { yield 'outer 1'; yield* innergenerator(); yield 'outer 2'; } const gen = outergenerator(); console.log(gen.next().value); // outer 1 console.log(gen.next().value); // inner 1 console.log(gen.next().value); // inner 2 console.log(gen.next().value); // outer 2
yield* 语法委托给innergenerator，在继续outergenerator 之前生成其所有值。
生成器中的错误处理也值得一提。您可以使用 throw() 方法将错误抛出到生成器中：
function* errorgenerator() { try { yield 'start'; yield 'middle'; yield 'end'; } catch (error) { console.error('caught:', error); yield 'error handled'; } } const gen = errorgenerator(); console.log(gen.next().value); // start console.log(gen.throw(new error('oops!')).value); // caught: error: oops! // error handled
这允许一些非常复杂的错误处理策略。
生成器还可以用于实现回溯算法。这是一个生成所有可能的项目组合的简单示例：
function* combinations(elements, length) { if (length === 0) { yield []; return; } for (let i = 0; i < elements.length; i++) { const first = elements[i]; const rest = elements.slice(i + 1); for (const combination of combinations(rest, length - 1)) { yield [first, ...combination]; } } } const items = ['a', 'b', 'c', 'd']; for (const combo of combinations(items, 2)) { console.log(combo); }
此生成器将生成给定项目的所有 2 元素组合。
生成器真正发挥作用的一个领域是处理大量数据。您可以创建仅计算所需内容的高效数据处理管道。这是一个逐行处理大文件的示例：
const fs = require('fs'); const readline = require('readline'); function* linereader(filename) { const filestream = fs.createreadstream(filename); const rl = readline.createinterface({ input: filestream, crlfdelay: infinity }); for await (const line of rl) { yield line; } } async function processfile(filename) { for await (const line of linereader(filename)) { // process each line here console.log(line); } } processfile('large_file.txt');
该生成器逐行读取文件，允许您处理大文件，而无需将它们完全加载到内存中。
生成器也可以用来实现 observable 模式。这是一个简单的实现：
function* observable() { while (true) { const data = yield; console.log('received:', data); } } const obs = observable(); obs.next(); // start the generator obs.next('hello'); // received: hello obs.next('world'); // received: world obs.next(42); // received: 42
该生成器充当观察者，处理它接收到的每条数据。
生成器的另一个很酷的用途是创建自定义控制结构。这是使用生成器的重试函数的示例：
function* retry(maxAttempts, fn) { for (let i = 0; i < maxAttempts; i++) { try { return yield fn(); } catch (error) { if (i === maxAttempts - 1) throw error; console.log(`Attempt ${i + 1} failed, retrying...`); } } } function* example() { const result = yield* retry(3, () => { if (Math.random() < 0.8) throw new Error('Random failure'); return 'Success!'; }); console.log(result); } const gen = example(); function run(gen) { const next = gen.next(); if (!next.done) Promise.resolve(next.value).then( value => run(gen), error => gen.throw(error) ); } run(gen);
此重试函数将在放弃之前尝试给定的函数最多 maxattempts 次。
总之，生成器是 javascript 的一项强大功能，可以帮助您编写更具表现力、更高效且可维护的代码。它们非常适合处理复杂的控制流、管理异步操作和处理大型数据集。虽然它们一开始看起来有点奇怪，但一旦掌握了它们的窍门，您就会发现在项目中使用它们的各种创造性方法。因此，继续吧，在您的下一个 javascript 项目中尝试一下生成器。您可能会惊讶于他们可以如此简化您的代码！
我们的创作
一定要看看我们的创作：
投资者中心 | 智能生活 | 时代与回响 | 令人费解的谜团 | 印度教 | 精英开发 | JS学校
我们在媒体上
科技考拉洞察 | 时代与回响世界 | 投资者中央媒体 | 令人费解的谜团 | 科学与时代媒介 | 现代印度教
