js 深入理解生成器

目录

  • 概述
  • 1 . 生成器基础
  • 2. 与普通函数的区别
  • 3. 通过 yield 中断执行
    • 3.1 yield 是干嘛的?
    • 3.2 yield 和 return 的区别
    • 3.3 每个生成器对象作用域都是独立的
    • 3.4 yeild 的使用位置
    • 3.5 生成器对象作为可迭代对象
    • 3.6 使用 yield 实现输入和输出
      • 3.6.1 yield实现输入
      • 3.6.1 yield 同时用于输入和输出
      • 3.6.1 代替数组实现 for-of 迭代
    • 3.7 yield * :产生可迭代对象
    • 3.8 使用 yield* 实现递归算法
  • 4. 生成器作为默认迭代器
  • 5. 提前终止生成器
    • 5.1. return()
    • 5.2. throw()
  • 总结

概述

红宝书上的定义 生成器是 ECMAScript 6 新增的一个极为灵活的结构,拥有在一个函数块内暂停和恢复代码执行的能力。是不是感觉没理解 ?我们用更通俗的描述:生成器是一种可以用来控制迭代器(iterator)的函数,它可以随时暂停,并可以在任意时候恢复。这种新能力具有深远的影响,比如,使用生成器可以自定义迭代器和实现协程。

1 . 生成器基础

  生成器的形式是一个函数,函数名称前面加一个星号( * )表示它是一个生成器。只要是可以定义函数的地方,就可以定义生成器。

// 生成器函数声明
function* generatorFn() {}
// 生成器函数表达式
let generatorFn = function* () {}
// 作为对象字面量方法的生成器函数
let foo = {* generatorFn() {}
}
// 作为类实例方法的生成器函数
class Foo {* generatorFn() {}
}
// 作为类静态方法的生成器函数
class Bar {static * generatorFn() {}
}

箭头函数不能用来定义生成器函数。

  标识生成器函数的星号不受两侧空格的影响:


// 等价的生成器函数:
function* generatorFnA() {}
function *generatorFnB() {}
function * generatorFnC() {}// 等价的生成器方法:
class Foo {
*generatorFnD() {}
* generatorFnE() {}
}

  调用生成器函数会产生一个生成器对象。生成器对象一开始处于暂停执行(suspended)的状态。与迭代器相似,生成器对象也实现了 Iterator 接口,因此具有 next() 方法。调用这个方法会让生成器开始或恢复执行。

function* generatorFn() {}
const g = generatorFn();
console.log(g); // generatorFn {<suspended>}
console.log(g.next); // f next() { [native code] }

  next() 方法的返回值类似于迭代器,有一个 done 属性和一个 value 属性。函数体为空的生成器函数中间不会停留,调用一次 next() 就会让生成器到达 done: true 状态。

function* generatorFn() {}
let generatorObject = generatorFn();
console.log(generatorObject); // generatorFn {<suspended>}
console.log(generatorObject.next()); // { done: true, value: undefined }

  value 属性是生成器函数的返回值,默认值为 undefined ,可以通过生成器函数的返回值指定:

function* generatorFn() {return 'foo';
}
let generatorObject = generatorFn();
console.log(generatorObject); // generatorFn {<suspended>}
console.log(generatorObject.next()); // { done: true, value: 'foo' }

  生成器函数只会在初次调用 next() 方法开始执行,如下所示:

function* generatorFn() {console.log('foobar');
}
// 初次调用生成器函数并不会打印日志
let generatorObject = generatorFn();
generatorObject.next(); // foobar

  生成器对象实现了 Iterable 接口,它们默认的迭代器是自引用的:

function* generatorFn() {}
console.log(generatorFn);
// f* generatorFn() {}
console.log(generatorFn()[Symbol.iterator]);
// f [Symbol.iterator]() {native code}
console.log(generatorFn());
// generatorFn {<suspended>}
console.log(generatorFn()[Symbol.iterator]());
// generatorFn {<suspended>}
const g = generatorFn();
console.log(g === g[Symbol.iterator]());
// true

  上面的代码中 const g = generatorFn(); console.log(g === g[Symbol.iterator]()); //true ,最后两行代码非常直观的展示了生成器的作用。

2. 与普通函数的区别

  我们先做一个实验看看:

//定义一个普通函数
function  generalFn(){console.log("普通函数: hello");
}function * generatorFn(){console.log("生成器: hello");
}let fn1 = generalFn();   // 执行一下普通函数
let fn2 = generatorFn(); //执行一下 生成器

  上述代码console返回如下:
在这里插入图片描述
   我们看到只用普通函数执行了函数体内的代码,生成器函数没用执行,这是为什么呢?我们调试工具,看一下 fn1 和 fn2 分别是什么对象。fn1 是普通函数的返回值,因为generalFn() 没有返回值,所以 fn1 为 undefined。 fn2 为 生成器对象,具体内容如下图:
在这里插入图片描述
   上图中的生成器状态显示为 suspended(挂起、暂停),生成器处于暂停状态,所以没有执行 console.log(“生成器: hello”); 如何将生成器恢复执行呢,可以使用 next() 函数,如下面代码:

function * generatorFn(){console.log("生成器: hello");
}let fn2 = generatorFn(); //执行一下 生成器
fn2.next(); //迭代一次

   执行返回如下图 :
在这里插入图片描述
   此时生成器状态处于closed,即执行完毕了:
在这里插入图片描述

  继续将代码改改,看看 关键字 yield 的一些基本作用:

 function * generatorFn(){console.log("生成器: hello");console.log("生成器: world");yield ;console.log("生成器:第三个单词");
}let fn2 = generatorFn(); //执行一下 生成器
fn2.next(); //迭代一次

执行结果:
在这里插入图片描述
  从图中我们发现程序第5行的 console.log(“生成器:第三个单词”); 没有执行,但执行了 第2行和第3行的 代码。那我们就在第2行 和第 9行上面打上断点,看看 生成器对象 fn2 的状态变化 :
在这里插入图片描述
  上图程序,先执行到第二个断点(即图片中的 64 行),然后在跳到第一个断点(上图中第57行)处继续运行,一直运行到上图中59行, fn2的状态都是 running 如下图:

在这里插入图片描述
  当调试按 f10 下一步时,会跳出 生成器函数,这是 fn2的状态 再次变为 suspended。自此,我们的实验可以得出结论:调用生成器函数生成的生成器对象初始是 suspended(挂起状态),调用 next() 方法恢复执行,一直遇到第一个 yield,再次将 fn2 设置为suspended状态,暂时退出生成器,等待下一次执行 next() 来恢复
  我们还可以继续实验,我们看看next() 返回的是什么,将上面代码最后一行稍作修改:

function * generatorFn(){console.log("生成器: hello");console.log("生成器: world");yield ;console.log("生成器:第三个单词");
}let fn2 = generatorFn(); //执行一下 生成器
console.log(fn2.next()); // 

在这里插入图片描述
   yield, 英语愿意是产出,EcmaScript 中使用这个单词,就是有 产出数值的意思,我们不妨在 yield 接一个 值试试,看一下下面的代码:

function * generatorFn(){console.log("生成器: hello");console.log("生成器: world");yield 1;console.log("生成器:第三个单词");yield {age:30,name :'pitt'};
}
let fn2 = generatorFn(); //执行一下 生成器
console.log(fn2.next()); //迭代一次
console.log(fn2.next()); //迭代第二次

结果如下:
在这里插入图片描述
综上所述:next() 返回的值 就是 yield 产出的值。

   做完了上述的实验,我们再看下面红宝书的内容,就容易理解多了。

3. 通过 yield 中断执行

3.1 yield 是干嘛的?

  yield 关键字可以让生成器停止和开始执行,也是生成器最有用的地方。生成器函数在遇到 yield关键字之前会正常执行。遇到这个关键字后,执行会停止,函数作用域的状态会被保留。停止执行的生成器函数只能通过在生成器对象上调用 next() 方法来恢复执行:

function* generatorFn() {yield;
}
let generatorObject = generatorFn();
console.log(generatorObject.next()); // { done: false, value: undefined }
console.log(generatorObject.next()); // { done: true, value: undefined }

3.2 yield 和 return 的区别

  此时的 yield 关键字有点像函数的中间返回语句,它生成的值会出现在 next() 方法返回的对象里。通过 yield 关键字退出的生成器函数会处在 done: false 状态;通过 return 关键字退出的生成器函数会处于 done: true 状态。

function* generatorFn() {yield 'foo';yield 'foo2';return 'baz';yield 'bar';}
let generatorObject = generatorFn();
console.log(generatorObject.next()); // { done: false, value: 'foo' }
console.log(generatorObject.next()); // { done: false, value: 'foo2' }
console.log(generatorObject.next()); // { done: true, value: 'baz' }
console.log(generatorObject.next()); // { done: true, value: undefined }    ,第三条语句是 return 语句。函数作用域就消失了,就无法输出 'bar' 了

3.3 每个生成器对象作用域都是独立的

  生成器函数内部的执行流程会针对每个生成器对象区分作用域。在一个生成器对象上调用 next() 不会影响其他生成器:

function* generatorFn() {yield 'foo';yield 'bar';return 'baz';
}
let generatorObject1 = generatorFn();
let generatorObject2 = generatorFn();
console.log(generatorObject1.next()); // { done: false, value: 'foo' }
console.log(generatorObject2.next()); // { done: false, value: 'foo' }
console.log(generatorObject2.next()); // { done: false, value: 'bar' }
console.log(generatorObject1.next()); // { done: false, value: 'bar' }

3.4 yeild 的使用位置

  yield 关键字只能在生成器函数内部使用,用在其他地方会抛出错误。类似函数的 return 关键字,yield 关键字必须直接位于生成器函数定义中,出现在嵌套的非生成器函数中会抛出语法错误:


// 有效
function* validGeneratorFn() {yield;
}
// 无效
function* invalidGeneratorFnA() {function a() {yield;}
}
// 无效
function* invalidGeneratorFnB() {const b = () => {yield;}
}
// 无效
function* invalidGeneratorFnC() {
(() => { yield;})();
}

3.5 生成器对象作为可迭代对象

  在生成器对象上显式调用 next() 方法的用处并不大。其实,如果把生成器对象当成可迭代对象,那么使用起来会更方便:

function* generatorFn() {yield 1;yield 2;yield 3;
}
for (const x of generatorFn()) {console.log(x);
}
// 1
// 2
// 3

  在需要自定义迭代对象时,这样使用生成器对象会特别有用。比如,我们需要定义一个可迭代对象,而它会产生一个迭代器,这个迭代器会执行指定的次数。使用生成器,可以通过一个简单的循环来实现:

function* nTimes(n) {while(n--) {yield;}
}
for (let _ of nTimes(3)) {console.log('foo');
}
// foo
// foo
// foo

  传给生成器的函数可以控制迭代循环的次数。在 n 为 0 时, while 条件为假,循环退出,生成器函数返回。

3.6 使用 yield 实现输入和输出

3.6.1 yield实现输入

  除了可以作为函数的中间返回语句使用, yield 关键字还可以作为函数的中间参数使用。上一次让生成器函数暂停的 yield 关键字会接收到传给 next() 方法的第一个值。这里有个地方不太好理解——第一次调用 next() 传入的值不会被使用,因为这一次调用是为了开始执行生成器函数:

function* generatorFn(initial) {console.log(initial);console.log(yield); //此处其实程序先调用 yield 挂起。然后继续等待下一个next(), 这条语句等到的就是 generatorObject.next('baz'); // 此时系统会将 'baz' 传递给yield,程序继续执行,此时 console.log(yield);等价于 console.log('baz')console.log(yield);
}
let generatorObject = generatorFn('foo');
generatorObject.next('bar'); // foo
generatorObject.next('baz'); // baz
generatorObject.next('qux'); // qux

   上面的代码在调试的时候,我们可以将所有行都打上断点,就能看到程序执行的顺序,就会明白 yield 可以作为参数是啥意思了,执行到第3行时具体执行顺序如下:
在这里插入图片描述

3.6.1 yield 同时用于输入和输出

  yield 关键字可以同时用于输入和输出,如下例所示:

function* generatorFn() {return yield 'foo';
}
let generatorObject = generatorFn();
console.log(generatorObject.next()); // { done: false, value: 'foo' }
console.log(generatorObject.next('bar')); // { done: true, value: 'bar' }

  因为函数必须对整个表达式求值才能确定要返回的值,所以它在遇到 yield 关键字时暂停执行并计算出要产生的值: “foo” 。下一次调用 next() 传入了 “bar” ,作为交给同一个 yield 的值。然后这个值被确定为本次生成器函数要返回的值。

3.6.1 代替数组实现 for-of 迭代

yield 关键字并非只能使用一次。比如,以下代码就定义了一个无穷计数生成器函数:

function* generatorFn() {for (let i = 0;;++i) {yield i;}
}
let generatorObject = generatorFn();
console.log(generatorObject.next().value); // 0
console.log(generatorObject.next().value); // 1
console.log(generatorObject.next().value); // 2
console.log(generatorObject.next().value); // 3
console.log(generatorObject.next().value); // 4
console.log(generatorObject.next().value); // 5

  假设我们想定义一个生成器函数,它会根据配置的值迭代相应次数并产生迭代的索引。初始化一个新数组可以实现这个需求,但不用数组也可以实现同样的行为:

function* nTimes(n) {for (let i = 0; i < n; ++i) {yield i;}
}
for (let x of nTimes(3)) {console.log(x);
}
// 0
// 1
// 2

  另外,使用 while 循环也可以,而且代码稍微简洁一点:

function* nTimes(n) {let i = 0;while(n--) {yield i++;}
}
for (let x of nTimes(3)) {console.log(x);
}
// 0
// 1
// 2

  这样使用生成器也可以实现范围和填充数组:

function* range(start, end) {while(end > start) {yield start++;}
}
for (const x of range(4, 7)) {console.log(x);
}
// 4
// 5
// 6
function* zeroes(n) {while(n--) {yield 0;}
}
console.log(Array.from(zeroes(8))); // [0, 0, 0, 0, 0, 0, 0, 0]

3.7 yield * :产生可迭代对象

  可以使用星号增强 yield 的行为,让它能够迭代一个可迭代对象,从而一次产出一个值:

// 等价的 generatorFn:
// function* generatorFn() {
// for (const x of [1, 2, 3]) {
// yield x;
// }
// }
function* generatorFn() {yield* [1, 2, 3];   // 可以看成调用 yield 三次,分别为 yield 1, yield 2, yield 3 ;
}
let generatorObject = generatorFn();
for (const x of generatorFn()) {console.log(x);
}
// 1
// 2
// 3

  与生成器函数的星号类似, yield 星号两侧的空格不影响其行为:

function* generatorFn() {yield* [1, 2];yield *[3, 4];yield * [5, 6];
}
for (const x of generatorFn()) {console.log(x);
}
// 1
// 2
// 3
// 4
// 5
// 6

   因为 yield* 实际上只是将一个可迭代对象序列化为一连串可以单独产出的值,所以这跟把 yield放到一个循环里没什么不同。下面两个生成器函数的行为是等价的:


function* generatorFnA() {for (const x of [1, 2, 3]) {yield x;}
}
for (const x of generatorFnA()) {console.log(x);
}
// 1
// 2
// 3
function* generatorFnB() {yield* [1, 2, 3];
}
for (const x of generatorFnB()) {console.log(x);
}
// 1
// 2
// 3

  yield* 的值是关联迭代器(紧跟在yield*之后的迭代器)返回 done: true 时的 value 属性。对于普通迭代器来说,这个值是undefined :


function* generatorFn() {console.log('iter value:', yield* [1, 2, 3]);  // yield 三次结束以后,才会调用console.log()方法
}
for (const x of generatorFn()) {console.log('value:', x);
}
// value: 1
// value: 2
// value: 3
// iter value: undefined

  对于生成器函数产生的迭代器来说,这个值就是生成器函数返回的值:

function* innerGeneratorFn() {yield 'foo';return 'bar';
}
function* outerGeneratorFn(genObj) {console.log('iter value:', yield* innerGeneratorFn());
}
for (const x of outerGeneratorFn()) {console.log('value:', x);
}
// value: foo
// iter value: bar

  这里我们有一个问题要注意: yield * 不能暂停函数。 我们来小结一下 yield 和 yield *:

  yield 关键字 允许函数在执行过程中暂停并保存其当前状态,以便稍后恢复执行。这允许函数按需生成值,而不是一次性生成所有值,从而节省内存并提高性能。特别是在处理大数据集或无限序列时,这种机制非常有用。
   yield * 主要用于处理可迭代对象,如数组、字符串等,它允许生成器函数展开一个可迭代对象,并将该对象的每个元素依次产生出来。例如,如果有一个生成器函数使用了 yield * 表达式来处理一个数组,那么该生成器函数会依次产生数组中的每个元素,而不是用于控制函数本身的执行流程或暂停。
   实际上 包含 yield * 的生成器函数生成的对象就像一个委托 ,yield * 将一个迭代器对象委托给 生成器对象。我们来看看下面代码:

function * Generator()
{console.log("hello");yield * ['a','b','c'];console.log("world");}let gObj = Generator();
console.log(gObj.next());	//输出: hello//输出:	{value: 'a', done: false}//这一个next() ,相当于启动生成器函数对象,当输出 ‘a’之后,暂停 ,此处执行器相当于遇到了 yield 'a',
console.log(gObj.next());	//输出:	{value: 'b', done: false}     此处执行器相当于遇到了 yield 'b',
console.log(gObj.next());	//输出:	{value: 'c', done: false}		 此处执行器相当于遇到了 yield 'c',
console.log(gObj.next());	//输出:	world//输出: {value: undefined, done: true}

   上面的代码,数组[‘a’,‘b’,‘c’] 的迭代 相当于委托给 生成器函数 Generator 的生成器对象 gObj 了。只要对gObj 迭代, 数组[‘a’,‘b’,‘c’] 也被迭代了。
   我们将上面代码改一下:

function * Generator()
{console.log("hello");yield * ['a','b','c'];console.log("world");}for( let a of Generator())
{console.log(a);
}

   输出结果如下:
在这里插入图片描述

3.8 使用 yield* 实现递归算法

  yield* 最有用的地方是实现递归操作,此时生成器可以产生自身。看下面的例子:

function* nTimes(n) {if (n > 0) {yield* nTimes(n - 1);yield n - 1;}console.log(n+100);
}
for (const x of nTimes(3)) {console.log(x);
}
// 100
// 0
// 101
// 1
// 102
// 2
// 103

  在这个例子中,每个生成器首先都会从新创建的生成器对象产出每个值,然后再产出一个整数。结果就是生成器函数会递归地减少计数器值,并实例化另一个生成器对象。从最顶层来看,这就相当于创建一个可迭代对象并返回递增的整数。
  使用递归生成器结构和 yield* 可以优雅地表达递归算法。下面是一个图的实现,用于生成一个随机的双向图:

class Node {constructor(id) {this.id = id;this.neighbors = new Set();}connect(node) {if (node !== this) {this.neighbors.add(node);node.neighbors.add(this);}}
}
class RandomGraph {constructor(size) {this.nodes = new Set();// 创建节点for (let i = 0; i < size; ++i) {this.nodes.add(new Node(i));}// 随机连接节点const threshold = 1 / size;for (const x of this.nodes) {for (const y of this.nodes) {if (Math.random() < threshold) {x.connect(y);}}}}
// 这个方法仅用于调试print() {for (const node of this.nodes) {const ids = [...node.neighbors].map((n) => n.id).join(',');console.log(`${node.id}: ${ids}`);}}
}
const g = new RandomGraph(6);
g.print();
// 示例输出:
// 0: 2,3,5
// 1: 2,3,4,5
// 2: 1,3
// 3: 0,1,2,4
// 4: 2,3
// 5: 0,4

  图数据结构非常适合递归遍历,而递归生成器恰好非常合用。为此,生成器函数必须接收一个可迭代对象,产出该对象中的每一个值,并且对每个值进行递归。这个实现可以用来测试某个图是否连通,即是否没有不可到达的节点。只要从一个节点开始,然后尽力访问每个节点就可以了。结果就得到了一个非常简洁的深度优先遍历:

class Node {constructor(id) {this.id = id;this.neighbors = new Set();}connect(node) {if (node !== this) {this.neighbors.add(node);node.neighbors.add(this);}}
}
class RandomGraph {constructor(size) {this.nodes = new Set();// 创建节点for (let i = 0; i < size; ++i) {this.nodes.add(new Node(i));}// 随机连接节点const threshold = 1 / size;for (const x of this.nodes) {for (const y of this.nodes) {if (Math.random() < threshold) {x.connect(y);}}}}
// 这个方法仅用于调试print() {for (const node of this.nodes) {const ids = [...node.neighbors].map((n) => n.id).join(',');console.log(`${node.id}: ${ids}`);}}isConnected() {			//测试图 是否连通,,即是否没有不可到达的节点const visitedNodes = new Set();function* traverse(nodes) {for (const node of nodes) {if (!visitedNodes.has(node)) {yield node;yield* traverse(node.neighbors);}}}//  取得集合中的第一个节点const firstNode = this.nodes[Symbol.iterator]().next().value;//  使用递归生成器迭代每个节点for (const node of traverse([firstNode])) {visitedNodes.add(node);}return visitedNodes.size === this.nodes.size;}
}
const g = new RandomGraph(6);
g.print();

4. 生成器作为默认迭代器

  因为生成器对象实现了 Iterable 接口,而且生成器函数和默认迭代器被调用之后都产生迭代器,所以生成器格外适合作为默认迭代器。下面是一个简单的例子,这个类的默认迭代器可以用一行代码产出类的内容:

class Foo {constructor() {this.values = [1, 2, 3];}* [Symbol.iterator]() {yield* this.values;}
}
const f = new Foo();
for (const x of f) {console.log(x);
}
// 1
// 2
// 3

  这里, for-of 循环调用了默认迭代器(它恰好又是一个生成器函数)并产生了一个生成器对象。这个生成器对象是可迭代的,所以完全可以在迭代中使用。

5. 提前终止生成器

  与迭代器类似,生成器也支持“可关闭”的概念。一个实现 Iterator 接口的对象一定有 next()方法,还有一个可选的 return() 方法用于提前终止迭代器。生成器对象除了有这两个方法,还有第三个方法: throw() 。

function* generatorFn() {}
const g = generatorFn();
console.log(g); // generatorFn {<suspended>}
console.log(g.next); // f next() { [native code] }
console.log(g.return); // f return() { [native code] }
console.log(g.throw); // f throw() { [native code] }

   return() 和 throw() 方法都可以用于强制生成器进入关闭状态。

5.1. return()

  return() 方法会强制生成器进入关闭状态。提供给 return() 方法的值,就是终止迭代器对象的值:

function* generatorFn() {for (const x of [1, 2, 3]) {yield x;}
}
const g = generatorFn();
console.log(g); // generatorFn {<suspended>}
console.log(g.return(4)); // { done: true, value: 4 }
console.log(g); // generatorFn {<closed>}

   与迭代器不同,所有生成器对象都有 return() 方法,只要通过它进入关闭状态,就无法恢复了。后续调用 next() 会显示 done: true 状态,而提供的任何返回值都不会被存储或传播:

function* generatorFn() {for (const x of [1, 2, 3]) {yield x;}
}
const g = generatorFn();
console.log(g.next()); // { done: false, value: 1 }
console.log(g.return(4)); // { done: true, value: 4 }
console.log(g.next()); // { done: true, value: undefined }
console.log(g.next()); // { done: true, value: undefined }
console.log(g.next()); // { done: true, value: undefined }

   for-of 循环等内置语言结构会忽略状态为 done: true 的 IteratorObject 内部返回的值。

function* generatorFn() {for (const x of [1, 2, 3]) {yield x;}
}
const g = generatorFn();
for (const x of g) {if (x > 1) {g.return(4);}console.log(x);
}
// 1
// 2

5.2. throw()

   throw() 方法会在暂停的时候将一个提供的错误注入到生成器对象中。如果错误未被处理,生成器就会关闭:

function* generatorFn() {for (const x of [1, 2, 3]) {yield x;}
}
const g = generatorFn();
console.log(g); // generatorFn {<suspended>}
try {g.throw('foo');
} catch (e) {console.log(e); // foo
}
console.log(g); // generatorFn {<closed>}

  不过,假如生成器函数内部处理了这个错误,那么生成器就不会关闭,而且还可以恢复执行。错误处理会跳过对应的 yield ,因此在这个例子中会跳过一个值。比如:

function* generatorFn() {for (const x of [1, 2, 3]) {try {yield x;} catch(e) {}}
}
const g = generatorFn();
console.log(g.next()); // { done: false, value: 1}
g.throw('foo');
console.log(g.next()); // { done: false, value: 3}

  在这个例子中,生成器在 try / catch 块中的 yield 关键字处暂停执行。在暂停期间, throw() 方法向生成器对象内部注入了一个错误:字符串 “foo” 。这个错误会被 yield 关键字抛出。因为错误是在生成器的 try / catch 块中抛出的,所以仍然在生成器内部被捕获。可是,由于 yield 抛出了那个错误,生成器就不会再产出值 2 。此时,生成器函数继续执行,在下一次迭代再次遇到 yield 关键字时产出了值 3 。

如果生成器对象还没有开始执行,那么调用 throw() 抛出的错误不会在函数内部被捕获,因为这相当于在函数块外部抛出了错误。

总结

  迭代是一种所有编程语言中都可以看到的模式。ECMAScript 6 正式支持迭代模式并引入了两个新的语言特性:迭代器和生成器。
  迭代器是一个可以由任意对象实现的接口,支持连续获取对象产出的每一个值。任何实现 Iterable接口的对象都有一个 Symbol.iterator 属性,这个属性引用默认迭代器。默认迭代器就像一个迭代器工厂,也就是一个函数,调用之后会产生一个实现 Iterator 接口的对象。
  迭代器必须通过连续调用 next() 方法才能连续取得值,这个方法返回一个 IteratorObject 。这个对象包含一个 done 属性和一个 value 属性。前者是一个布尔值,表示是否还有更多值可以访问;后者包含迭代器返回的当前值。这个接口可以通过手动反复调用 next() 方法来消费,也可以通过原生消费者,比如 for-of 循环来自动消费。
  生成器是一种特殊的函数,调用之后会返回一个生成器对象。生成器对象实现了 Iterable 接口,因此可用在任何消费可迭代对象的地方。生成器的独特之处在于支持 yield 关键字,这个关键字能够暂停执行生成器函数。使用 yield 关键字还可以通过 next() 方法接收输入和产生输出。在加上星号之后, yield 关键字可以将跟在它后面的可迭代对象序列化为一连串值。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/426774.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【JVM安装MySQL】

环境 > VMware Workstation Pro > CentOS 7 >Navicat Premium Lite > MobaXterm添加 MySQL Yum 仓库 根据操作系统在下载界面选取对应yum库进行下载 wget https://dev.mysql.com/get/mysql80-community-release-el7-9.noarch.rpm在文件下载界面安装 rpm -ivh mysq…

<<编码>> 第 14 章 反馈与触发器(3)--锁存器与触发器 示例电路

电平触发 D 型触发器 info::操作说明 鼠标单击逻辑输入切换 0|1 状态 因复位和置位不应同时处在高电平, 因此在输入处加入一个非门反向, 然后复位和置位输入合并为 数据(Data) 输入 注: 当保持位为 0 时, 数据输入无效 primary::在线交互操作链接 https://cc.xiaogd.net/?star…

Stylized Smooth Clouds 卡通风格化云朵包

下载:​​Unity资源商店链接资源下载链接 效果图:

Spring考点总结

01.Spring框架的基本理解 关键字:核心思想IOC\AOP\作用(解耦、简化)&#xff0c;简单描述框架组成 Spring框架是一款轻量级的开发框架&#xff0c;核心思想是IOC&#xff08;控制反转&#xff09;和AOP&#xff08;面向切面编程&#xff09;&#xff0c; 为Java应用程序开发…

数字IC设计\FPGA 职位经典笔试面试整理--语法篇 Verilog System Verilog(部分)

注&#xff1a; 资料都是基于网上一些博客分享和自己学习整理而成的 Verilog 1. 数据类型 Verilog一共有19种数据类型 基础四种数据类型&#xff1a;reg型&#xff0c;wire型&#xff0c;integer型&#xff0c;parameter型 reg型   reg类型是寄存器数据类型的关键字。寄存…

软考(中级-软件设计师)(0919)

软考 一、软件设计师-历年考试考点分布情况-上午-计算机与软件工程知识 知识点分数说明比例软件工程基础知识11开发模型、设计原则、测试方法、质量特性、CMM、Pert图、风险管理14.67%面向对象12面向对象基本概念、面向对象分析与设计、UML、常见算法16.00%数据结构与算法10…

【HarmonyOS NEXT】DevEco快速实现真机截屏,并保存到电脑

点日志点照机图标选一个路径保存图片在ide中右键图片&#xff0c;点复制电脑随便找个位置保存图片https://developer.huawei.com/consumer/cn/doc/harmonyos-guides-V5/ide-screenshot-V5

使用Ubuntu耳机输出正弦波信号

最近有一个项目想使用喇叭发出一个标准的正弦波测试信号&#xff0c;故记录下操作过程 sudo apt install libasound2-dev 否则有可能会报错&#xff1a; alsaaudio.c:28:10: fatal error: alsa/asoundlib.h: No such file or directory 安装pyalsaaudio&#xff1a; pip …

IE浏览器彻底去除浏览器缓存的方法

1.浏览器右上方如图操作 2.点击后会弹出窗口&#xff0c;如图操作 3.点击查看文件如图操作 4&#xff0e;点击后会弹出一个文件夹&#xff0c;在文件夹内CtrlA全选删除全部文件就可以&#xff0c;有提示直接确认即可

智能车镜头组入门(三)巡线

镜头组的特点是通过摄像头来获取赛道的信息&#xff0c;从而达到前瞻的效果&#xff0c;完成转向和速度决策。 我们的方案&#xff0c;带上元素识别&#xff0c;大概在TC264上5ms一帧&#xff0c;所以我们开了100hz的图象。 之前我看别的博客上有人说&#xff0c;他们组的50帧…

光伏检测数据集(六种)

光伏检测数据集(六种) 1.并网光伏系统故障诊断数据集 (该数据集为excel张&#xff0c;对故障类型完成标注)。 2.分布式光伏目标检测数据集 (该数据集共4000张分布式光伏高清图片&#xff0c;均已标注) 3.光伏电池板缺陷检测数据集 (该数据集共2400张光伏板缺陷高清图片&#xf…

DC-DC降压10A电源降压可调模块24V转12V9V5V3V-AH1514芯片

AH1514&#xff1a;一款高效率小体积的DC-DC降压电源芯片 摘要&#xff1a;本文介绍了一款高性能的DC-DC降压电源芯片——AH1514&#xff0c;该芯片具有24V转12V、9V、5V、3V可调输出&#xff0c;支持7V-38V输入&#xff0c;20A峰值输出电流&#xff0c;且具有小体积、高效率的…

【计算机网络】TCP的可靠传输机制、标记位以及编程结构

文章目录 一、TCP的可靠传输的工作原理1、确认应答机制和捎带应答机制2、超时重传3、快速重传4、滑动窗口5、流量控制 未 PSH6、拥塞控制7、延迟应答8、TCP 以段为单位发送数据 二、TCP 首部的六个标记位1、URG2、ACK3、PSH4、RST5、SYN6、FIN 三、TCP网络并发编程 一、TCP的可…

下载docker镜像报错,dial tcp x.x.x.x:443: connect: connection refused

原因是:国外的连接超时了. 解决方案改为阿里云的数据源 打开阿里云 搜索&#xff1a;容器镜像服务 ACR 把你自己的这个直接复制在linux sudo mkdir -p /etc/docker sudo tee /etc/docker/daemon.json <<-EOF { "registry-mirrors": ["你自己的"] }…

面试官问:如何解决消息队列的延时以及过期失效问题?

消息的可靠性传输 ActiveMQ 要保证消息的可靠性&#xff0c;除了消息的持久化&#xff0c;还包括两个方面&#xff0c;一是生产者发送的消息可以被ActiveMQ收到&#xff0c;二是消费者收到了ActiveMQ发送的消息。 生产者 非持久化又不在事务中的消息&#xff0c;可能会有消…

黑神话悟空+云技术,游戏新体验!

近期&#xff0c;一款名为黑神话悟空的游戏因其独特的艺术风格和创新的技术实现在玩家中产生了不小的影响。 而云桌面技术作为一种新兴的解决方案&#xff0c;正在改变人们的游戏体验方式&#xff0c;使得高性能游戏可以在更多设备上流畅运行。 那么&#xff0c;黑神话悟空如…

《深入理解 Java 线程池:高效管理线程的利器》

线程池 1. 什么是线程池&#xff1f; ​ 线程池内部维护了若干个线程&#xff0c;没有任务的时候&#xff0c;这些线程都处于等待空闲状态。如果有新的线程任务&#xff0c;就分配一个空闲线程执行。如果所有线程都处于忙碌状态&#xff0c;线程池会创建一个新线程进行处理或…

滑动窗口(6)_找到字符串中所有字母异位词

个人主页&#xff1a;C忠实粉丝 欢迎 点赞&#x1f44d; 收藏✨ 留言✉ 加关注&#x1f493;本文由 C忠实粉丝 原创 滑动窗口(6)_找到字符串中所有字母异位词 收录于专栏【经典算法练习】 本专栏旨在分享学习算法的一点学习笔记&#xff0c;欢迎大家在评论区交流讨论&#x1f4…

STM32 芯片启动过程

目录 一、前言二、STM32 的启动模式三、STM32 启动文件分析1、栈 Stack2、堆 Heap3、中断向量表 Vectors3.1 中断响应流程 4、复位程序 Reset_Handler5、中断服务函数6、用户堆栈初始化 四、STM32 启动流程分析1、初始化 SP、PC 及中断向量表2、设置系统时钟3、初始化堆栈并进入…

【Transformer深入学习】之一:Sinusoidal位置编码的精妙

看苏神的文章提到&#xff1a;Transformer原论文使用Sinusoidal位置编码&#xff0c;作为位置编码的一个显式解&#xff0c;Google 在原论文中对它的描述寥寥无几&#xff0c;只是简单提及了它可以表达相对位置信息&#xff0c;并未提及这个编码的合理性。 看了几篇文章&#x…