关于javascript:ES6深度解析Generators

介绍ES6 Generators

什么是Generators（生成器函数）？让咱们先来看看一个例子。

function* quips(name) {  yield "hello " + name + "!";  yield "i hope you are enjoying the blog posts";  if (name.startsWith("X")) {    yield "it's cool how your name starts with X, " + name;  }  yield "see you later!";}

这是一只会谈话的猫的一些代码，可能是当今互联网上最重要的一种利用。它看起来有点像一个函数，对吗？这被称为生成器-函数，它与函数有很多共同之处。但你马上就能看到两个不同之处。

• 一般函数以function结尾，生成器函数以function*结尾
• 在生成器函数中，yield是一个关键字，语法看起来像return。不同的是，函数（甚至是生成器函数）只能返回一次，而生成器函数能够“yield”任何次数。yield表达式暂停了生成器的执行，同时它能够在当前再次复原。

Generators能够做什么

当你调用生成器-函数quips()时会产生什么？

> var iter = quips("jorendorff");  [object Generator]> iter.next()  { value: "hello jorendorff!", done: false }> iter.next()  { value: "i hope you are enjoying the blog posts", done: false }> iter.next()  { value: "see you later!", done: false }> iter.next()  { value: undefined, done: true }

你可能曾经十分习惯于一般函数和它们的行为形式。当你调用它们时，它们会立刻开始运行，并始终运行到返回或抛出异样。所有这些对任何JS程序员来说都是第二天性。调用一个生成器看起来也是一样的：quips("jorendorff")。

然而当你调用一个生成器时，它还没有开始运行。相同，它返回一个暂停的Generator对象iter（在下面的例子中调用）。你能够把这个Generator对象看作是一个函数调用，在调用前被解冻。具体来说，它被解冻在生成器函数的顶端，就在运行其第一行代码之前。每次你调用Generator对象的办法.next()时，函数调用都会自我冻结，并运行到下一个yield表达式为止。这就是为什么咱们每次调用下面的iter.next()办法，都会失去一个不同的字符串值。这些都是由函数quips()中产生的值。在最初一次iter.next()调用中，咱们终于达到了生成器-函数的起点，所以后果的字段是 。达到一个函数的起点就像返回一样，这就是为什么后果的字段是 { value: undefined, done: true }

当初可能是一个好时机，回到会谈话的猫的演示页面，真正地玩一玩代码。试着把yield放在一个循环外面。会产生什么？从技术上讲，每次Generator执行yield时，它的堆栈--局部变量、参数、长期值以及以后在Generator主体中的执行地位--都会从堆栈中删除。然而，Generator对象会保留对这个堆栈框架的援用（或正本），以便当前.next()调用能够从新激活它并继续执行。

值得指出的是，Generator不是线程。在有线程的语言中，多段代码能够同时运行，通常会导致比赛条件、非确定性和苦涩的性能。Generator则齐全不是这样的。当一个Generator运行时，它与调用者在同一个线程中运行。执行的程序是程序的、确定的，而不是并发的。与零碎线程不同，Generator只在其函数体中表明的yield点上暂停运行。

好了。咱们晓得Generator是什么。咱们曾经看到了一个Generator的运行，暂停本人，而后复原执行。当初有个大问题。这种奇怪的能力怎么可能有用？

Generators就是迭代器（Generators are iterators）

ES6迭代器不仅仅是一个繁多的内置类。它们是该语言的一个扩大点。你能够通过实现两个办法[Symbol.iterator]()和next()来创立你本人的迭代器。然而实现一个接口至多要做一点工作。让咱们看看迭代器的实现在实践中是什么样的。作为一个例子，让咱们做一个简略的迭代器range for (;;)，它只是从一个数字到另一个数字进行计数，就像一个老式的C循环一样。

// This should "ding" three timesfor (var value of range(0, 3)) {  alert("Ding! at floor #" + value);}

这里有一个解决方案，应用ES6类class。

class RangeIterator {  constructor(start, stop) {    this.value = start;    this.stop = stop;  }  [Symbol.iterator]() { return this; }  next() {    var value = this.value;    if (value < this.stop) {      this.value++;      return {done: false, value: value};    } else {      return {done: true, value: undefined};    }  }}// Return a new iterator that counts up from 'start' to 'stop'.function range(start, stop) {  return new RangeIterator(start, stop);}

代码示例

这就是在Java或Swift中实现迭代器的状况。这并不坏。但也不齐全是微不足道的。这段代码里有什么谬误吗？这可不好说。它看起来齐全不像咱们在这里试图模拟的原始循环：for (;;)，迭代器协定迫使咱们拆除了循环。在这一点上，你可能对迭代器感到有点淡漠。它们可能很好用，但仿佛很难实现。

你可能不会想倡议咱们在JS语言中引入一个疯狂的、令人费解的新控制流构造，只是为了使迭代器更容易构建。但既然咱们有生成器Generator，咱们能在这里应用它们吗？让咱们试试吧。

function* range(start, stop) {  for (var i = start; i < stop; i++)    yield i;}

代码示例

下面的4行range()代码能够间接代替以前的23行实现，包含整个类RangeIterator。就是因为Generator是迭代器，所以这所有才是可能的。所有的生成器都有一个内置的next()和[Symbol.iterator]()的实现。 你只需写出循环的行为。

在没有Generator的状况下实现迭代器，就像被迫齐全用被动语态来写一封长邮件。当简略地说出你的意思不是一个选项时，你最终说的货色可能会变得相当简单。"我的意思是，我的意思是，我必须在不应用循环语法的状况下形容一个循环的性能，所以RangeIterator又长又奇怪。而Generator就是答案。

咱们还能够如何利用生成器作为迭代器的能力呢？

• 让任何对象都能够迭代。只需写一个Generator函数来遍历，在遍历时产生（yield）每个值。而后把这个生成器函数装置为this对象的[Symbol.iterator]办法。

• 简化建数组函数。假如你有一个函数，每次调用都会返回一个数组的后果，就像上面这个函数：

  //将一维数组'图标'切分成长度为'rowLength'的数组function splitIntoRows(icons, rowLength) {var rows = [];for (var i = 0; i < icons.length; i += rowLength) {  rows.push(icons.slice(i, i + rowLength));}return rows;}

  应用Generator会让这种代码更短一些。

  function* splitIntoRows(icons, rowLength) {for (var i = 0; i < icons.length; i += rowLength) {  yield icons.slice(i, i + rowLength);}}

  执行时惟一区别是，它不是一次性计算所有的后果并返回一个数组，而是返回一个迭代器，而后依据须要一一计算结果。

• 异样大小的后果。你不可能建设一个有限的数组。然而你能够返回一个Generator，生成一个无尽的序列，每个调用者能够从其中提取他们须要的任何数量的值。
• 重构简单的循环。你有一个微小的俊俏的函数吗？你想把它分解成两个更简略的局部吗？Generator是增加到你的重构工具箱中的一把新刀。当你面对一个简单的循环时，你能够把代码中产生数据的局部合成进去，把它变成一个独自的生成器-函数。而后将循环改为：for (var data of myNewGenerator(args))

• 解决可迭代数据的工具。ES6并没有提供一个扩大库，用于过滤、映射，以及个别状况下对任意的可迭代数据集进行任意的解决。然而Generator对于构建你所须要的工具来说是十分棒的，只须要几行代码。例如，假如你须要一个新的在DOM NodeLists上遍历的办法，而不仅仅是Arrays。小菜一碟：创立Array.prototype.filter

  function* filter(test, iterable) {for (var item of iterable) {  if (test(item))    yield item;}}

  那么Generator是否有用呢？当然，它们是实现自定义迭代器的一种惊人的简略办法，而且迭代器是整个ES6的数据和循环的新规范。但这并不是Generator的全副性能。这甚至可能不是它们所做的最重要的事件。

生成器与异步代码（Generators and asynchronous code）

上面是我前段时间写的一些JS代码。

          };        })      });    });  });});

兴许你曾经在本人的代码中看到了这样的货色。异步API通常须要一个回调，这意味着每次你做什么都要写一个额定的匿名函数。因而，如果你有一点代码做三件事，而不是三行代码，你就会看到三个缩进档次的代码。上面是我写的一些更多的JS代码。

}).on('close', function () {  done(undefined, undefined);}).on('error', function (error) {  done(error);});

异步API有错误处理常规，而不是异样。不同的API有不同的约定。在大多数API中，默认状况下，谬误会被默默地放弃。在一些API中，即便是一般的胜利实现也是默认放弃的。直到现在，这些问题都是咱们为异步编程付出的代价。咱们曾经承受了这样的事实：异步代码看起来并不像相应的同步代码那样丑陋和简略。

Generator提供了新的心愿：咱们不用再写那样俊俏的代码。

Q.async()是一个实验性的尝试，它应用Generators与Promises来产生相似于相应同步代码的异步代码。比如说:

// Synchronous code to make some noise.function makeNoise() {  shake();  rattle();  roll();}// Asynchronous code to make some noise.// Returns a Promise object that becomes resolved// when we're done making noise.function makeNoise_async() {  return Q.async(function* () {    yield shake_async();    yield rattle_async();    yield roll_async();  });}

次要的区别是，异步版本必须在调用异步函数的每个中央增加关键字yield。在该版本中增加像语句if或try/catch块这样的代码，就像在一般的同步版本中增加它一样。与其余编写异步代码的形式相比，这感觉不像是在学习一种全新的语言。（延长浏览）

因而，Generator为一种新的异步编程模型指明了方向，它仿佛更适宜人类的大脑。这项工作正在进行中。在其余方面，更好的语法可能会有帮忙。一项对于异步函数的倡议，建设在Promises和Generators的根底上，并从C#的相似性能中取得灵感，已被提上ES7的议程。