JavaScript 生成器：通过暂停功能增强您的代码！

javascript 生成器：通过暂停功能增强您的代码！

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);
}

这个生成器将永远持续生成斐波那契数。这是一个无限序列，但我们只计算我们需要的值。

这给我们带来了生成器最酷的事情之一：惰性求值。他们仅在我们要求时计算值。这对于大型数据集或复杂的计算来说非常高效。

让我们看一个更实际的例子。假设您正在为大型数据集构建分页系统：

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 项目中尝试一下生成器。您可能会惊讶于他们可以如此简化您的代码！

我们的创作

一定要看看我们的创作：

我们在媒体上

以上就是JavaScript 生成器：通过暂停功能增强您的代码！的详细内容，更多请关注硕下网其它相关文章！