程序员元宵加班搞代码:生成器

原创
03/01 19:46
阅读数 661

程序员元宵加班搞代码:生成器

常规函数只返回一个值(或不返回任何值)。

生成器可以按需一个接一个地返回(“yield”)多个值。它们与可迭代对象一起工作得很好,允许轻松地创建数据流。

生成器函数

为了创建一个生成器,我们需要一个特殊的语法结构:function*,也就是所谓的“生成器函数”。

它是这样的:

functiongenerateSequence({
  yield 1;
  yield 2;
  return 3;
}

生成器函数的行为与常规函数不同。当这样的函数被调用时,它不会运行它的代码。相反,它返回一个特殊的对象,称为“生成器对象”,来管理执行。

来看看吧:

functiongenerateSequence({
  yield 1;
  yield 2;
  return 3;
}

// "generator function" creates "generator object"
let generator = generateSequence();
alert(generator); // [object Generator]

函数代码还没有开始执行:

生成器的主要方法是next()。当被调用时,它会一直执行直到最近的yield 语句(value可以省略,那么它是未定义的)。然后函数暂停执行,生成的值返回到外部代码。

next()的结果总是一个具有两个属性的对象:

  • value:生成的值。
  • done:如果函数代码已经完成,则为 true,否则为 false

例如,这里我们创建了生成器,并获得它的第一个生成值:

functiongenerateSequence({
  yield 1;
  yield 2;
  return 3;
}

let generator = generateSequence();

let one = generator.next();

alert(JSON.stringify(one)); // {value: 1, done: false}

到目前为止,我们只得到第一个值,函数执行在第二行:

让我们再次调用generator.next()``。它继续执行代码并返回下一个yield`:

let two = generator.next();

alert(JSON.stringify(two)); // {value: 2, done: false}

并且,如果我们第三次调用它,执行将到达结束函数的return语句:

现在生成器完成了。我们应该看到done:trueprocess value:3作为最终结果。

generator.next()的新调用不再有意义。如果我们执行它们,它们将返回相同的对象:{done: true}

function* f(…) or function *f(…)?

两种语法都是正确的。

但通常首选第一种语法,因为星号*表示它是一个生成器函数,它描述的是类型,而不是名称,所以它应该坚持使用function关键字。

生成器是可迭代的

在查看next()方法时,您可能已经猜到生成器是可迭代的。

我们可以使用for..of循环遍历它们的值:

functiongenerateSequence({
  yield 1;
  yield 2;
  return 3;
}

let generator = generateSequence();

for(let value of generator) {
  alert(value); // 1, then 2
}

看起来比调用.next().value 好多了,对吧?但是请注意:上面的例子显示了1,然后是2,仅此而已。它没有显示3!

这是因为对. .执行时忽略最后一个值:true。因此,如果我们想让for..of显示所有的结果。对于,我们必须退让:

functiongenerateSequence({
  yield 1;
  yield 2;
  yield 3;
}

let generator = generateSequence();

for(let value of generator) {
  alert(value); // 1, then 2, then 3
}

由于生成器是可迭代的,我们可以调用所有相关的功能,例如spread语法:

functiongenerateSequence({
  yield 1;
  yield 2;
  yield 3;
}

let sequence = [0, ...generateSequence()];

alert(sequence); // 0, 1, 2, 3

在上面的代码中,…generateSequence()将可迭代生成器对象转换为一组项(请参阅Rest参数和spread语法一章中的spread语法)。

Using generators for iterables

let range = {
  from1,
  to5,

  // for..of range calls this method once in the very beginning
  [Symbol.iterator]() {
    // ...it returns the iterator object:
    // onward, for..of works only with that object, asking it for next values
    return {
      currentthis.from,
      lastthis.to,

      // next() is called on each iteration by the for..of loop
      next() {
        // it should return the value as an object {done:.., value :...}
        if (this.current <= this.last) {
          return { donefalsevaluethis.current++ };
        } else {
          return { donetrue };
        }
      }
    };
  }
};

// iteration over range returns numbers from range.from to range.to
alert([...range]); // 1,2,3,4,5

通过将generator函数作为Symbol.iterator提供,可以使用它进行迭代。

这里是相同的范围,但更紧凑:

let range = {
  from1,
  to5,

  *[Symbol.iterator]() { // a shorthand for [Symbol.iterator]: function*()
    for(let value = this.from; value <= this.to; value++) {
      yield value;
    }
  }
};

alert( [...range] ); // 1,2,3,4,5

这是可行的,因为range[Symbol.iterator]()现在返回一个生成器,而生成器方法正是for..of预计:

  • .next() 方法
  • 返回 {value: ..., done: true/false}

当然,这不是巧合。在JavaScript语言中添加生成器时考虑到了迭代器,以便轻松实现它们。

带有生成器的变体比range的原始可迭代代码要简洁得多,并且保持了相同的功能。

生成器可以永远生成值

在上面的例子中,我们生成了有限序列,但是我们也可以生成一个永久生成值的生成器。例如,伪随机数的无穷序列。

生成器组合

生成器组合是生成器的一个特殊特性,它允许透明地将生成器相互“嵌入”。

例如,我们有一个生成数字序列的函数:

functiongenerateSequence(start, end{
  for (let i = start; i <= end; i++) yield i;
}

现在我们想重用它来生成一个更复杂的序列:

  • 首先,数字0...9(字符代码48…57),
  • 后面跟着大写字母A..Z(字符代码65…90)
  • 后面跟着小写字母a..z(字符代码97…122)

我们可以使用这个序列,例如通过选择其中的字符来创建密码(也可以添加语法字符),但是让我们先生成它。

在常规函数中,为了组合来自多个其他函数的结果,我们调用它们,存储结果,然后在最后连接。

对于生成器,有一个特殊的yield*语法来“嵌入”(组合)一个生成器到另一个生成器中。

functiongenerateSequence(start, end{
  for (let i = start; i <= end; i++) yield i;
}

functiongeneratePasswordCodes({

  // 0..9
  yield* generateSequence(4857);

  // A..Z
  yield* generateSequence(6590);

  // a..z
  yield* generateSequence(97122);

}

let str = '';

for(let code of generatePasswordCodes()) {
  str += String.fromCharCode(code);
}

alert(str); // 0..9A..Za..z

yield*指令将执行委托给另一个生成器。这个术语意味着yield* gen在生成器生成器上迭代,并透明地将它的yield传递给外部。就好像这些值是由外部生成器生成的一样。

结果与从嵌套生成器中内联代码是一样的:

functiongenerateSequence(start, end{
  for (let i = start; i <= end; i++) yield i;
}

functiongenerateAlphaNum({

  // yield* generateSequence(48, 57);
  for (let i = 48; i <= 57; i++) yield i;

  // yield* generateSequence(65, 90);
  for (let i = 65; i <= 90; i++) yield i;

  // yield* generateSequence(97, 122);
  for (let i = 97; i <= 122; i++) yield i;

}

let str = '';

for(let code of generateAlphaNum()) {
  str += String.fromCharCode(code);
}

alert(str); // 0..9A..Za..z

生成器组合是一种将一个生成器流插入另一个生成器流的自然方法。它不使用额外的内存来存储中间结果。

yield 是一条双行道

在此之前,生成器类似于iterable对象,使用特殊的语法来生成值。但事实上,它们更强大、更灵活。

这是因为yield是一条双向通道:它不仅向外部返回结果,还可以在生成器内部传递值。

为此,我们应该调用generator.next(arg),并带一个参数。这个论证就是yield的结果。

让我们来看一个例子:

functiongen({
  // Pass a question to the outer code and wait for an answer
  let result = yield "2 + 2 = ?"// (*)

  alert(result);
}

let generator = gen();

let question = generator.next().value; // <-- yield returns the value

generator.next(4); // --> pass the result into the generator

第一个调用generator.next()应始终不带实参(如果传入,实参将被忽略)。它开始执行并返回第一个yield的结果“2+2=?”。此时生成器暂停执行,并保持在(*)行上。

然后,如上图所示,yield的结果进入调用代码中的question变量。

generator.next(4)上,生成器恢复,结果为4:let result = 4

请注意,外部代码不必立即调用next(4)。这可能需要时间。这不是问题:发电机会等待。

例如:

// resume the generator after some time
setTimeout(() => generator.next(4), 1000);

正如我们所见,与常规函数不同,生成器和调用代码可以通过在next/yield中传递值来交换结果。

为了让事情更明显,这里有另一个例子,有更多的调用:

functiongen({
  let ask1 = yield "2 + 2 = ?";

  alert(ask1); // 4

  let ask2 = yield "3 * 3 = ?"

  alert(ask2); // 9
}

let generator = gen();

alert( generator.next().value ); // "2 + 2 = ?"

alert( generator.next(4).value ); // "3 * 3 = ?"

alert( generator.next(9).done ); // true

执行情况:

  • 第一个.next()开始执行…它到达第一个yield。

结果返回到外部代码。

  • 第二个.next(4)将4作为第一个yield的结果传递回生成器,并继续执行。

  • 它达到了第二个收益,它成为生成器调用的结果。

  • 第三个next(9)将9作为第二个yield的结果传递给生成器,并继续执行到达函数末尾的操作,完成:true。

这就像一个“乒乓球”游戏。每个next(值)(不包括第一个)都向生成器传递一个值,该值成为当前收益率的结果,然后返回下一个收益率的结果。

generator.throw

正如我们在上面的例子中所观察到的,外部代码可以将一个值传递给生成器,作为yield的结果。

但是它也可能在那里引发(抛出)错误。这是很自然的,因为错误是一种结果。

要将错误传递给yield,应该调用generator.throw(err)。在这种情况下,在具有该yield的行中抛出err

例如,这里“2 + 2 = ?”的收益率会导致一个错误:

functiongen({
  try {
    let result = yield "2 + 2 = ?"// (1)

    alert("The execution does not reach here, because the exception is thrown above");
  } catch(e) {
    alert(e); // shows the error
  }
}

let generator = gen();

let question = generator.next().value;

generator.throw(new Error("The answer is not found in my database")); // (2)

382/5000 在第(2)行抛出到生成器中的错误会导致第(1)行中出现yield异常。在上面的例子中,try..catch抓住它并展示它。

如果我们没有捕获它,那么就像任何异常一样,它将从生成器“掉出”到调用代码中。

调用代码的当前行是带有generator.throw,标记为(2)。所以我们可以在这里抓住它,像这样:

functiongenerate({
  let result = yield "2 + 2 = ?"// Error in this line
}

let generator = generate();

let question = generator.next().value;

try {
  generator.throw(new Error("The answer is not found in my database"));
catch(e) {
  alert(e); // shows the error
}

如果我们没有在那里捕获到错误,那么它就会像往常一样落到外部调用代码(如果有的话),如果没有捕获到,就会终止脚本。

总结

  • 生成器是由生成器函数function* f(…){…}创建的。

  • 生成器(仅)内部存在yield操作符。

  • 外部代码和生成器可以通过next/yield调用交换结果。

在现代JavaScript中,很少使用生成器。但有时它们也会派上用场,因为函数在执行期间与调用代码交换数据的能力是非常独特的。当然,它们对于制作可迭代对象非常有用。

另外,在下一章中,我们将学习异步生成器,它用于读取异步生成的数据流(例如通过网络进行分页读取)。的循环。

在网络编程中,我们经常使用流数据,所以这是另一个非常重要的用例。


本文分享自微信公众号 - 人生代码(lijinwen1996329ken)。
如有侵权,请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”,欢迎正在阅读的你也加入,一起分享。

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部