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学校
我们在媒体上
科技考拉洞察 | 时代与回响世界 | 投资者中央媒体 | 令人费解的谜团 | 科学与时代媒介 | 现代印度教
