掌握JavaScript中的迭代器和生成器，顺便了解一下async、await的原理

前言

相信很多人对迭代器和生成器都不陌生，当提到async和await的原理时，大部分人可能都知道async、await是Promise+生成器的语法糖，其原理具体是怎么做的呢？下面通过这篇文章带你详细了解一下迭代器和生成器，以及带你从生成器一步步推导到async和await。

1.迭代器（Iterator）

1.1.什么是迭代器？

迭代器是确使用户在容器对象（链表或数组）上遍访的对象，使用该接口无需关心对象的内部实现细节。

  • 迭代器的定义可能比较抽象，简单来说迭代器就是一个对象，可用于帮助我们对某个数据结构（链表、数组）进行遍历；

  • 在JavaScript中，迭代器也是一个具体的对象，并且这个对象必须符合迭代器协议（iterator protocol）；

  • 什么是迭代器协议？

    • 在JavaScript中就是指这个对象必须实现一个特定的next方法，并且next方法有如下要求；
    • next方法可接收0个或者1个参数（在生成器中next可以接收1个参数），并且需返回一个对象，对象包含以下两个属性：
      • done：值为Boolean，如果迭代器可以迭代产生下一个值，就为false，如果已经迭代完毕，就为true；
      • value：迭代器返回的值，如果done为false，value一般为undefined；

  • 编写一个最简单的迭代器：

    1. const iterator = {
    2.   next: function() {
    3.     return { done: false, value: 123 }
    4.   }
    5. }

1.2.迭代器的基本使用

明白了迭代器的基本定义，下面就来实现一下符合迭代器协议的对象吧，并且看看其它的一些基本用法。比如，需要通过迭代器访问一个数组：

（1）创建一个迭代器对象

  1. const names = ['curry', 'kobe', 'klay']
  3. let index = 0 // 通过一个index来记录当前访问的位置
  4. const iterator = {
  5.   next() {
  6.     if (index < names.length) {
  7.       return { done: false, value: names[index++] }
  8.     } else {
  9.       return { done: true, value: undefined }
  10.     }
  11.   }
  12. }
  14. console.log(iterator.next()) // { done: false, value: 'curry' }
  15. console.log(iterator.next()) // { done: false, value: 'kobe' }
  16. console.log(iterator.next()) // { done: false, value: 'klay' }
  17. console.log(iterator.next()) // { done: true, value: undefined }

（2）实现生成迭代器的函数

  • 如果每次需要去访问一个数组就去编写一个对应的迭代器对象肯定是很麻烦的；
  • 可以封装一个函数，用于生成一个访问数组的迭代器；
  1. function createIterator(arr) {
  2.   let index = 0
  3.   return {
  4.     next() {
  5.       if (index < arr.length) {
  6.         return { done: false, value: arr[index++] }
  7.       } else {
  8.         return { done: true, value: undefined }
  9.       }
  10.     }
  11.   }
  12. }
  1. const names = ['curry', 'kobe', 'klay']
  2. // 调用createIterator函数，生成一个访问names数组的迭代器
  3. const namesIterator = createIterator(names)
  5. console.log(namesIterator.next()) // { done: false, value: 'curry' }
  6. console.log(namesIterator.next()) // { done: false, value: 'kobe' }
  7. console.log(namesIterator.next()) // { done: false, value: 'klay' }
  8. console.log(namesIterator.next()) // { done: true, value: undefined }

1.3.可迭代对象

1.3.1.什么是可迭代对象？

上面提到了迭代器是一个对象，并且符合迭代器协议，那么什么是可迭代对象呢？它与迭代器又有什么区别？

  • 迭代器是一个符合迭代器协议（iterator protocol）的对象，对象内实现了一个特定的next方法；
  • 而可迭代对象是一个符合可迭代协议（iterable protocol）的对象，对象内实现了一个Symbol.iterator方法，并且该方法返回一个迭代器对象；
  • 所以，可以说可迭代对象包含了迭代器对象，可迭代对象中实现了一个特定方法用于返回迭代器对象；

如下，iteratorObj就是一个可迭代对象：

  1. const iteratorObj = {
  2.   names: ['curry', 'kobe', 'klay'],
  3.   [Symbol.iterator]: function() {
  4.     let index = 0
  5.     return {
  6.       // 注意：这里的next需要使用箭头函数，否则this访问不到iteratorObj
  7.       next: () => {
  8.         if (index < this.names.length) {
  9.           return { done: false, value: this.names[index++] }
  10.         } else {
  11.           return { done: true, value: undefined }
  12.         }
  13.       }
  14.     }
  15.   }
  16. }
  1. // 调用iteratorObj中的Symbol.iterator得到一个迭代器
  2. const iterator = iteratorObj[Symbol.iterator]()
  4. console.log(iterator.next()) // { done: false, value: 'curry' }
  5. console.log(iterator.next()) // { done: false, value: 'kobe' }
  6. console.log(iterator.next()) // { done: false, value: 'klay' }
  7. console.log(iterator.next()) // { done: true, value: undefined }
1.3.2.JS内置的可迭代对象

上面的可迭代对象都是由自己实现的，其实在JavaScript中为我们提供了很多可迭代对象，如：String、Array、Map、Set、arguments对象、NodeList（DOM集合）等。

  1. // 1.String
  2. const str = 'abc'
  4. const strIterator = str[Symbol.iterator]()
  5. console.log(strIterator.next()) // { value: 'a', done: false }
  6. console.log(strIterator.next()) // { value: 'b', done: false }
  7. console.log(strIterator.next()) // { value: 'c', done: false }
  8. console.log(strIterator.next()) // { value: undefined, done: true }
  10. // 2.Array
  11. const names = ['curry', 'kobe', 'klay']
  12. console.log(names[Symbol.iterator])
  14. const namesIterator = names[Symbol.iterator]()
  15. console.log(namesIterator.next()) // { value: 'curry', done: false }
  16. console.log(namesIterator.next()) // { value: 'kobe', done: false }
  17. console.log(namesIterator.next()) // { value: 'klay', done: false }
  18. console.log(namesIterator.next()) // { value: undefined, done: true }
  20. // 3.Map/Set
  21. const set = new Set
  22. set.add(10)
  23. set.add(20)
  24. set.add(30)
  26. const setIterator = set[Symbol.iterator]()
  27. console.log(setIterator.next()) // { value: 10, done: false }
  28. console.log(setIterator.next()) // { value: 20, done: false }
  29. console.log(setIterator.next()) // { value: 30, done: false }
  30. console.log(setIterator.next()) // { value: undefined, done: true }
1.3.3.可迭代对象应用场景

可迭代对象在实际应用中特别常见，像一些语法的使用、创建一些对象和方法调用都用到了可迭代对象。

  • JS中的语法：for...of、展开语法、解构等。

    • for...of可用于遍历一个可迭代对象，其原理就是利用迭代器的next函数，如果done为false，就从返回的对象中拿到value返回给我们，而对象不是一个可迭代对象，所以对象不能使用for...of遍历；

      1. const num = [1, 2, 3]
      2. for (const item of num) {
      3.   console.log(item) // 1 2 3
      4. }
      5. // 遍历上面自己定义的可迭代对象iteratorObj也是可以的
      6. for (const item of iteratorObj) {
      7.   console.log(item) // curry kobe klay
      8. }
      1. const obj = { name: 'curry', name: 30 }
      2. for (const key of obj) {
      3.   console.log(key)
      4. }

    • 为什么数组能使用展开语法，其原理也是用到了迭代器，在使用...对数组进行展开时，也是通过迭代器的next去获取数组的每一项值，然后存放到新数组中；

      1. const names = ['james', 'green']
      2. // 将数组和iteratorObj通过扩展进行合并
      3. const newNames = [...names, ...iteratorObj]
      4. console.log(newNames) // [ 'james', 'green', 'curry', 'kobe', 'klay' ]

    • 可迭代对象都是可以使用解构语法的，像数组、字符串为什么可以使用解构，其原因就在这，原理也是通过迭代器一个个取值然后再赋值给对应变量；

      1. const str = 'abc'
      2. const nums = [1, 2, 3]
      4. const [str1, str2, str3] = str
      5. console.log(str1, str2, str3) // a b c
      7. const [num1, num2, num3] = nums
      8. console.log(num1, num2, num3) // 1 2 3
      10. const [name1, name2, name3] = iteratorObj
      11. console.log(name1, name2, name3) // curry kobe klay

    • 注意：在扩展语法和解构语法中，我们知道数组可以使用，但是对象也可以使用呀，为什么没有提到对象呢？因为对象的扩展和解构是在ES9中新增的特性，其原理并不是使用迭代器实现的，只是ECMA提供给我们的一种操作对象的新语法而已；

  • JS创建对象：new Map([Iterable])、new WeakMap([Iterable])、new Set([Iterable])、new WeakSet([Iterable])等。

    1. // 1.Set
    2. const set = new Set(iteratorObj)
    3. console.log(set) // Set(3) { 'curry', 'kobe', 'klay' }
    5. // 2.Array.from
    6. const names = Array.from(iteratorObj)
    7. console.log(names) // [ 'curry', 'kobe', 'klay' ]

  • JS方法调用：Promise.all(Iterable)、Promise.race(Iterable)、Array.from(Iterable)等。

    1. // 传入的可迭代对象中的每个值，会使用Promise.resolve进行包裹
    2. Promise.all(iteratorObj).then(res => {
    3.   console.log(res) // [ 'curry', 'kobe', 'klay' ]
    4. })

扩展：现在我们都知道了for...of可用于遍历一个可迭代对象，如果在遍历过程中终端了呢？因为使用break、continue、return、throw都是可以中断遍历的，既然for...of遍历的原理是基于迭代器的，那么在for...of中进行中断操作，一定是可以被迭代器监听到的，上面说了，在迭代器中有一个next方法，其实还可以指定一个return方法，如果遍历过程中断了，就会去调用return方法，注意return方法也要返回和next方法一样的对象。这种情况就称之为迭代器的中断。

  1. const iteratorObj = {
  2.   names: ['curry', 'kobe', 'klay'],
  3.   [Symbol.iterator]: function() {
  4.     let index = 0
  5.     return {
  6.       next: () => {
  7.         if (index < this.names.length) {
  8.           return { done: false, value: this.names[index++] }
  9.         } else {
  10.           return { done: true, value: undefined }
  11.         }
  12.       },
  13.       return() {
  14.         console.log('哎呀，我被中断了！')
  15.         return { done: true, value: undefined }
  16.       }
  17.     }
  18.   }
  19. }
  21. for (const item of iteratorObj) {
  22.   console.log(item)
  23.   if (item === 'kobe') break
  24. }

1.3.4.自定义可迭代类

上面提到了对象不是一个可迭代对象，所以对象不能使用for...of遍历，如果我们想要实现通过for...of遍历对象呢？那么可以自己实现一个类，这个类的实例化对象是可迭代对象。

  • 实现一个Person类，并且Person类中实现了Symbol.iterator方法用于返回一个迭代器；
  • Person类的实例化对象p中包含一个friends数组，通过for...of遍历p对象时，可以将friends数组的每一项遍历出来；
  1. class Person {
  2.   constructor(name, age, friends) {
  3.     this.name = name
  4.     this.age = age
  5.     this.friends = friends
  6.   }
  8.   [Symbol.iterator]() {
  9.     let index = 0
  10.     return {
  11.       next: () => {
  12.         if (index < this.friends.length) {
  13.           return { done: false, value: this.friends[index++] }
  14.         } else {
  15.           return { done: true, value: undefined }
  16.         }
  17.       }
  18.     }
  19.   }
  20. }

简单看一下效果：

  1. const p = new Person('curry', 30, ['kobe', 'klay', 'green'])
  2. for (const name of p) {
  3.   console.log(name) // kobe klay green
  4. }

2.生成器（Generator）

2.1.什么是生成器？

生成器是ES6中新增的一种控制函数执行的方案，它可以帮助我们控制函数的暂停和执行。生成器是一种特殊的迭代器，所以生成器也是一个对象，并且可以调用next方法。那么怎么创建一个生成器对象呢？

创建生成器对象需要使用生成器函数，生成器函数和普通函数不一样，主要有以下特点：

  • 生成器函数的声明需要在function后加上一个符号*；
  • 在生成器函数中可以使用yield关键字来分割函数体代码，控制函数的执行；
  • 生成器函数调用的返回值就是生成器对象了；

2.2.生成器的基本使用

实现一个生成器函数，该函数的执行可以通过返回的生成器对象进行控制。

  1. function* generatorFn() {
  2.   console.log('函数开始执行~')
  4.   console.log('函数第一段代码执行...')
  5.   yield
  6.   console.log('函数第二段代码执行...')
  7.   yield
  8.   console.log('函数第三段代码执行...')
  9.   yield
  10.   console.log('函数第四段代码执行...')
  12.   console.log('函数执行结束~')
  13. }
  15. // 调用generatorFn获取生成器
  16. const generator = generatorFn()
  18. generator.next()
  19. console.log('------------------------')
  20. generator.next()
  21. console.log('------------------------')
  22. generator.next()
  23. console.log('------------------------')
  24. generator.next()

2.3.生成器next方法的返回值

上面说到了生成器是一种特殊的迭代器，那么调用next方法肯定也是有返回值的，并且返回值是一个包含done、value属性的对象。

  1. function* generatorFn() {
  2.   console.log('函数第一段代码执行...')
  3.   yield
  4.   console.log('函数第二段代码执行...')
  5.   yield
  6.   console.log('函数第三段代码执行...')
  7.   yield
  8.   console.log('函数第四段代码执行...')
  9. }
  11. // 调用generatorFn获取生成器
  12. const generator = generatorFn()
  14. console.log(generator.next())
  15. console.log('------------------------')
  16. console.log(generator.next())
  17. console.log('------------------------')
  18. console.log(generator.next())
  19. console.log('------------------------')
  20. console.log(generator.next())

从打印结果可以看出来，next返回的对象中value是没有值的，当执行到最后一段代码后，done的值就为true了：

如果需要指定next返回值中的value，那么可以通过在yield后面跟上一个值或者表达式，就可以将对应的值传递到next返回对象value中了。

  1. function* generatorFn() {
  2.   console.log('函数第一段代码执行...')
  3.   yield 10
  4.   console.log('函数第二段代码执行...')
  5.   yield 20
  6.   console.log('函数第三段代码执行...')
  7.   yield 30
  8.   console.log('函数第四段代码执行...')
  9. }
  11. // 调用generatorFn获取生成器
  12. const generator = generatorFn()
  14. console.log(generator.next())
  15. console.log('------------------------')
  16. console.log(generator.next())
  17. console.log('------------------------')
  18. console.log(generator.next())
  19. console.log('------------------------')
  20. console.log(generator.next())

观察以上打印结果，在执行完第四段代码后，调用的next返回值为{ value: undefined, done: true }，原因是后面已经没有yield了，而且当函数没有指定返回值时，最后会默认执行return undefined。

2.4.生成器next方法的参数传递

在前面介绍迭代器定义时，提到迭代器的next可以传递0个或1个参数，而可以传递1个参数的情况就是生成器的next可以传递一个参数，而给每一段代码传递过去的参数可以通过yield来接收。

  1. function* generatorFn(value) {
  2.   console.log('函数第一段代码执行...', value)
  3.   const value1 = yield 10
  5.   console.log('函数第二段代码执行...', value1)
  6.   const value2 = yield 20
  8.   console.log('函数第三段代码执行...', value2)
  9.   const value3 = yield 30
  11.   console.log('函数第四段代码执行...', value3)
  12. }
  14. // 调用generatorFn获取生成器
  15. const generator = generatorFn('参数0')
  17. console.log(generator.next())
  18. console.log('------------------------')
  19. console.log(generator.next('参数1'))
  20. console.log('------------------------')
  21. console.log(generator.next('参数2'))
  22. console.log('------------------------')
  23. console.log(generator.next('参数3'))

next参数传递解释：

  • next中传递的参数是会被上一个yield接收的，这样可以方便下面代码使用这个参数，所以给next传递参数，需要从第二个next开始传递；
  • 如果第一段代码需要使用参数呢？可以在调用生成器函数时传递参数过去，供第一段代码使用；

2.5.生成器的return方法

return方法也可以给生成器函数传递参数，但是调用return后，生成器函数就会中断，之后再调用next就不会再继续生成值了。

  1. function* generatorFn() {
  2.   console.log('函数第一段代码执行...')
  3.   yield
  5.   console.log('函数第二段代码执行...')
  6.   yield
  8.   console.log('函数第三段代码执行...')
  9.   yield
  11.   console.log('函数第四段代码执行...')
  12. }
  14. // 调用generatorFn获取生成器
  15. const generator = generatorFn()
  17. console.log(generator.next())
  18. console.log('------------------------')
  19. console.log(generator.next())
  20. console.log('------------------------')
  21. console.log(generator.return(123))
  22. console.log('------------------------')
  23. console.log(generator.next())
  24. console.log(generator.next())
  25. console.log(generator.next())
  26. console.log(generator.next())
  27. console.log(generator.next())

上面的执行return方法，相当于函数内部执行了return：

  1. function* generatorFn() {
  2.   console.log('函数第一段代码执行...')
  3.   yield
  5.   console.log('函数第二段代码执行...')
  6.   const value = yield
  7.   return value
  9.   console.log('函数第三段代码执行...')
  10.   yield
  12.   console.log('函数第四段代码执行...')
  13. }
  15. // 调用generatorFn获取生成器
  16. const generator = generatorFn()
  18. console.log(generator.next())
  19. console.log('------------------------')
  20. console.log(generator.next())
  21. console.log('------------------------')
  22. console.log(generator.next(123))
  23. console.log('------------------------')
  24. console.log(generator.next())
  25. console.log(generator.next())
  26. console.log(generator.next())
  27. console.log(generator.next())
  28. console.log(generator.next())

2.6.生成器的throw方法

throw方法可以给生成器函数内部抛出异常。

  • 生成器调用throw方法抛出异常后，可以在生成器函数中进行捕获；
  • 通过try catch捕获异常后，后续的代码还是可以正常执行的；
  1. function* generatorFn() {
  2.   console.log('函数第一段代码执行...')
  3.   yield 10
  5.   console.log('函数第二段代码执行...')
  6.   try {
  7.     yield 20
  8.   } catch (err) {
  9.     console.log(err)
  10.   }
  12.   console.log('函数第三段代码执行...')
  13.   yield 30
  15.   console.log('函数第四段代码执行...')
  16. }
  18. // 调用generatorFn获取生成器
  19. const generator = generatorFn()
  21. console.log(generator.next())
  22. console.log('------------------------')
  23. console.log(generator.next())
  24. console.log('------------------------')
  25. console.log(generator.throw('err message'))
  26. console.log('------------------------')
  27. console.log(generator.next())

2.7.生成器替换迭代器

在前面实现了一个生成迭代器的函数，实现过程还需要进行判断，并自己返回对应的对象，下面就用生成器来实现一个生成迭代器的函数。

  • 方式一：根据数组元素的个数，执行yield；

    1. function* createIterator(arr) {
    2.   let index = 0
    3.   yield arr[index++]
    4.   yield arr[index++]
    5.   yield arr[index++]
    6. }

  • 方式二：遍历数组，执行yield；

    1. function* createIterator(arr) {
    2.   for (const item of arr) {
    3.     yield item
    4.   }
    5. }

  • 方式三：执行yield*，后面可以跟上一个可迭代对象，它会依次迭代其中每一个值；

    1. function* createIterator(arr) {
    2.   yield* arr
    3. }

测试一下以上三种方法，执行结果都是一样的：

  1. const names = ['curry', 'kobe', 'klay']
  2. const iterator = createIterator(names)
  4. console.log(iterator.next()) // { value: 'curry', done: false }
  5. console.log(iterator.next()) // { value: 'kobe', done: false }
  6. console.log(iterator.next()) // { value: 'klay', done: false }
  7. console.log(iterator.next()) // { value: undefined, done: true }

3.异步请求的处理方案

在进行异步请求时，如果出现了这样一个需求，下一次的请求需要拿到上一次请求的结果。如下是使用Promise封装的一个request方法。

  1. function request(url) {
  2.   return new Promise((resolve, reject) => {
  3.     setTimeout(() => {
  4.       resolve(url)
  5.     }, 300)
  6.   })
  7. }

实现上面的需求可以怎么做呢？

3.1.方案一：使用Promise的then进行嵌套调用

  • 在then中拿到结果后，再去做下一次请求，以此类推；
  • 缺点：形成了回调地狱；
  1. request('/aaa').then(res => {
  2.   request(res + '/bbb').then(res => {
  3.     request(res + '/ccc').then(res => {
  4.       console.log(res) // /aaa/bbb/ccc
  5.     })
  6.   })
  7. })

3.2.方案二：使用Promise的then的返回值

  • 虽然可以解决回调地狱问题，但是阅读性不佳；
  1. request('/aaa').then(res => {
  2.   return request(res + '/bbb')
  3. }).then(res => {
  4.   return request(res + '/ccc')
  5. }).then(res => {
  6.   console.log(res) // /aaa/bbb/ccc
  7. })

3.3.方案三：使用Promise和Generator处理

  1. function* getRequestData() {
  2.   const res1 = yield request('/aaa')
  3.   const res2 = yield request(res1 + '/bbb')
  4.   const res3 = yield request(res2 + '/ccc')
  5.   console.log(res3)
  6. }

  • 手动执行生成器的next方法；

    1. const generator = getRequestData()
    2. generator.next().value.then(res => {
    3.   generator.next(res).value.then(res => {
    4.     generator.next(res).value.then(res => {
    5.       generator.next(res) // /aaa/bbb/ccc
    6.     })
    7.   })
    8. })

  • 自动执行生成器的next方法：如果手动执行嵌套层级过多的话是不方便的，那么可以借助递归的思想实现一个自动执行生成器的函数；

    1. function autoGenerator(generatorFn) {
    2.   const generator = generatorFn()
    4.   function recursion(res) {
    5.     const result = generator.next(res)
    6.     // 如果done值为true，说明结束了
    7.     if (result.done) return result.value
    8.     // 没有结束，继续调用Promise的then
    9.     result.value.then(res => {
    10.       recursion(res)
    11.     })
    12.   }
    14.   recursion()
    15. }
    17. autoGenerator(getRequestData) // /aaa/bbb/ccc

  • 使用第三方库来执行生成器：像自动执行生成器函数，早就已经有第三方库帮助我们实现了，如co；

    1. const co = require('co')
    2. co(getRequestData) // /aaa/bbb/ccc

3.4.方案四：使用async和await

async和await是我们解决异步回调的最终解决方案，它可以让我们异步的代码，看上去是同步执行的。

  1. async function getRequestData() {
  2.   const res1 = await request('/aaa')
  3.   const res2 = await request(res1 + '/bbb')
  4.   const res3 = await request(res2 + '/ccc')
  5.   console.log(res3)
  6. }
  8. getRequestData() // /aaa/bbb/ccc

4.async和await的原理

相信从上面讲述的四个异步请求的处理方案中，就可以看出来async、await和生成器的关系了。

  • 将生成器函数的*换成async；
  • 将生成器函数中的yield换成await；
  • 两种方案所体现出的效果和代码书写形式几乎差不多；

总结：

  • async和await的原理其实就是Promise+生成器实现的；
  • 为什么async、await能够让异步代码看上去是同步执行的，其原因就在于生成器的next方法可以对函数内代码的执行进行控制，当上一次请求拿到结果后，再去执行下一次next；
  • 所以为什么说async和await只是Promise+生成器的语法糖，其原理就在这；

掌握JavaScript中的迭代器和生成器，顺便了解一下async、await的原理的更多相关文章

  1. JavaScript中的迭代器和生成器[未排版]

    JavaScript中的迭代器 在软件开发领域,"迭代"的意思是按照顺序反复多次执行一段程序,通常会有明确的终止条件. ECMAScript 6规范新增了两个高级特性:迭代器和生成 ...

  2. python is、==区别；with；gil；python中tuple和list的区别；Python 中的迭代器、生成器、装饰器

    1. is 比较的是两个实例对象是不是完全相同,它们是不是同一个对象,占用的内存地址是否相同 == 比较的是两个对象的内容是否相等 2. with语句时用于对try except finally 的优 ...

  3. pytorch :: Dataloader中的迭代器和生成器应用

    在使用pytorch训练模型,经常需要加载大量图片数据,因此pytorch提供了好用的数据加载工具Dataloader. 为了实现小批量循环读取大型数据集,在Dataloader类具体实现中,使用了迭 ...

  4. Python中的迭代器和生成器

    本文以实例详解了python的迭代器与生成器,具体如下所示: 1. 迭代器概述: 迭代器是访问集合元素的一种方式.迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束.迭代器只能往前不会后 ...

  5. 终于理解Python中的迭代器和生成器了！

    迭代器和生成器 目录 迭代器和生成器 可迭代对象和迭代器 基础概念 判断 for循环本质 不想用for循环迭代了,如何使用迭代器? 列表推导式 生成器Generator 概念 如何实现和使用? 生成器 ...

  6. 学习迭代器实现C#异步编程——仿async/await（一）

    .NET 4.5的async/await真是个神奇的东西,巧妙异常以致我不禁对其实现充满好奇,但一直难以窥探其门径.不意间读了此篇强文<Asynchronous Programming in C ...

  7. javascript中的迭代器

    1.forEach迭代器 forEach方法接收一个函数作为参数,对数组中每个元素使用这个函数,只调用这个函数,数组本身没有任何变化 //forEach迭代器 function square(num) ...

  8. Python中的迭代器、生成器

    from collections import Iterable, Iterator 1. 可迭代(iterable)对象 参考官网链接 class I: def __init__(self, v): ...

  9. python中的迭代器和生成器学习笔记总结

    生成器就是一个在行为上和迭代器非常类似的对象.   是个对象! 迭代,顾名思意就是不停的代换的意思,迭代是重复反馈过程的活动,其目的通常是为了逼近所需目标或结果.每一次对过程的重复称为一次“迭代”,而 ...

随机推荐

  1. git配置修改,git自定义命令,合并命令

    一.自定义合并命令 将add commit push合并 git config --global alias.cmp '!f() { git add -A && git commit ...

  2. php 生成唯一订单号5种方法

    第一种 private function doCreateOrderNumber($time){ $i=1; $dd = date('Ymd',$time); $aa = 'OH'.$dd; $res ...

  3. 02 基础 卸载JDK 安装JDK Java程序运行机制

    基础 JDK:Java Development Kit(Java开发者工具 包含JRE和JVM) JRE:Java Runtime Environment(java运行时环境,包含JVM) JVM:J ...

  4. LGP3349口胡

    建议改为:如何使用FWT直接把反演题草过去 需要清楚 FWT 的本质是什么. 首先我们有一个明显的 DP: 设 \(dp[u][x][S]\) 代表 \(u\) 在图中为 \(x\),子树包含集合 \ ...

  5. 神经网络中的Heloo，World，基于MINST数据集的LeNet

    前言 最近刚开始接触机器学习,记录下目前的一些理解,以及看到的一些好文章mark一下 1.MINST数据集 MNIST 数据集来自美国国家标准与技术研究所, National Institute of ...

  6. 高级IO模型之kqueue和epoll

    目录 简介 block IO和nonblocking IO IO多路复用和select poll epoll kqueue epoll和kqueue的优势 简介 任何一个程序都离不开IO,有些是很明显 ...

  7. Python_Learn,Python背景的介绍

    一.计算机程序的运行方式 机器语言编写的程序可以在计算机上直接运行,而汇编语言和高级余语言写的程序(通常称为源程序)则需要"翻译"成机器语言才能运行.源程序"翻译&quo ...

  8. MySQL—索引（Index）

    前言: 关于MySql索引数据结构和实现原理的讲解值得阅读一下: 实现原理:https://www.cnblogs.com/songwenjie/p/9415016.htm 索引数据结构:https: ...

  9. 一道有意思的 CSS 面试题，FizzBu​​zz ~

    FizzBu​​zz 是一道很有意思的题目.我们来看看题目: 如果遇见了 3 的倍数要说 Fizz,5 的倍数就说 Buzz,如果即是 3 的倍数又是 5 的倍数就说 FizzBuzz. 如果是在一些 ...

  10. (转载)linux下Yum的$releasever和$basearch的取值

    https://blog.csdn.net/whatday/article/details/51097456