23_Iterator-Generator - 《JavaScript高级程序设计》

什么是迭代器
什么是生成器
生成器替代迭代器
异步处理方案
- 解决

title: Iterator-Generator
categories: Javascript
tag:

迭代器
生成器
date: 2021-11-30 01:16:34

什么是迭代器

迭代器是对象，对象符合迭代器协议

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

其行为像数据库中的光标，迭代器最早出现在 1974 年设计的 CLU 编程语言中；
在各种编程语言的实现中，迭代器的实现方式各不相同，但是基本都有迭代器，比如 Java、Python 等；

从迭代器的定义我们可以看出来，迭代器是帮助我们对某个数据结构进行遍历的对象。

在 JavaScript 中，迭代器也是一个具体的对象，这个对象需要符合迭代器协议（iterator protocol）：

迭代器协议定义了产生一系列值（无论是有限还是无限个）的标准方式；
那么在 js 中这个标准就是一个特定的 next 方法；

next 方法有如下的要求：

一个无参数或者一个参数的函数，返回一个应当拥有以下两个属性的对象：
done（boolean）
1. 如果迭代器可以产生序列中的下一个值，则为 false。（这等价于没有指定 done 这个属性。）
2. 如果迭代器已将序列迭代完毕，则为 true。这种情况下，value 是可选的，如果它依然存在，即为迭代结束之后的默认返回值。
value
1. 迭代器返回的任何 JavaScript 值。done 为 true 时可省略。

迭代器的基本使用

迭代器遍历数组

//数组
const names = ['abc', 'bcd', 'cde']
//以前遍历数组
for (let i = 0; i < names.length; i++) {
  names[i]
}
//创建迭代器对象来访问数组
let index = 0
const namesIterator = {
  next: function () {
    // return { done: false, value: 'abc' }
    // return { done: false, value: 'bcd' }
    // return { done: false, value: 'cde' }
    // return { done: true, value: undefined }
    if (index < names.length) {
      return { done: false, value: names[index++] }
    } else {
      return { done: true, value: undefined }
    }
  }
}
console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())
// 运行结果：
// { done: false, value: 'abc' }
// { done: false, value: 'bcd' }
// { done: false, value: 'cde' }
// { done: true, value: undefined }
// { done: true, value: undefined }

生成迭代器的函数

封装一个生成迭代器的函数

const names = ['abc', 'bcd', 'cde']
const nums = [10, 20, 30, 40, 50]
function createArrayIterator(array) {
  let index = 0
  return {
    next: function () {
      if (index < array.length) {
        return { done: false, value: array[index++] }
      } else {
        return { done: true, value: undefined }
      }
    }
  }
}
const numsIterator = createArrayIterator(nums)
console.log(numsIterator.next())
console.log(numsIterator.next())
console.log(numsIterator.next())
console.log(numsIterator.next())
console.log(numsIterator.next())
console.log(numsIterator.next())

可迭代对象

但是上面的代码整体来说看起来是有点奇怪的：

我们获取一个数组的时候，需要自己创建一个 index 变量，再创建一个所谓的迭代器对象；
事实上我们可以对上面的代码进行进一步的封装，让其变成一个可迭代对象；

什么又是可迭代对象呢？

它和迭代器是不同的概念；
当一个对象实现了 iterable protocol 协议时，它就是一个可迭代对象；
这个对象的要求是必须实现 @@iterator 方法，在代码中我们使用 Symbol.iterator 访问该属性；

当我们要问一个问题，我们转成这样的一个东西有什么好处呢？

当一个对象变成一个可迭代对象的时候，进行某些迭代操作，比如 for…of 操作时，其实就会调用它的@@iterator 方法；

迭代器	可迭代对象
是一个对象，符合迭代器协议	第一个对象，符合可迭代协议

//这就是可迭代对象
const iterableObj = {
  names: ['abc', 'bcd', 'cde'],
  [Symbol.iterator]: function () {
    let index = 0
    return {
      next: () => {
        if (index < this.names.length) {
          return { done: false, value: this.names[index++] }
        } else {
          return { done: true, value: undefined }
        }
      }
    }
  }
}
console.log(iterableObj[Symbol.iterator]) //[Function: [Symbol.iterator]]
const iterator = iterableObj[Symbol.iterator]()
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())
//每次生成的是新的迭代对象
const iterator2 = iterableObj[Symbol.iterator]()
console.log(iterator2.next())
console.log(iterator2.next())
console.log(iterator2.next())
console.log(iterator2.next())

可迭代对象的应用

我们知道，对象不是一个可迭代对象

const obj = {
  name: 'why',
  age: 18
}
for (const item of obj) {
}
// TypeError: obj is not iterable

const iterableObj = {
  names: ['abc', 'bcd', 'cde'],
  [Symbol.iterator]: function () {
    let index = 0
    return {
      next: () => {
        if (index < this.names.length) {
          return { done: false, value: this.names[index++] }
        } else {
          return { done: true, value: undefined }
        }
      }
    }
  }
}
const obj = {
  name: 'why',
  age: 18
}
for (const item of iterableObj) {
  console.log(item) //这样子就可以迭代了
}

原生迭代器对象

事实上我们平时创建的很多原生对象已经实现了可迭代协议，会生成一个迭代器对象的：

String、Array、Map、Set、arguments对象、NodeList集合；

const names = ['a', 'b', 'c']
console.log(names[Symbol.iterator])
const iterator1 = names[Symbol.iterator]()
console.log(iterator1.next())
console.log(iterator1.next())
console.log(iterator1.next())
console.log(iterator1.next())

所以数组之所以可以使用 for…of 遍历，就是因为有[Symbol.iterator]

可迭代对象的应用

那么这些东西可以被用在哪里呢？

JavaScript 中语法：for …of、展开语法（spread syntax）、yield*（后面讲）、解构赋值（Destructuring_assignment）；

//这是由于迭代器
const names = ['a', 'b', 'c']
const newNames = [...names, ...iterableObj]
console.log(newNames)
//这个不是迭代器.这是ES9新增的
const obj = { name: 'why', age: 18 }
const newObj = { ...obj }

创建一些对象时：new Map([Iterable])、new WeakMap([iterable])、new Set([iterable])、new WeakSet([iterable]);
一些方法的调用：Promise.all(iterable)、Promise.race(iterable)、Array.from(iterable);

//创建数组
//创建数组
const arr1 = Array.from(iterableObj)
console.log(arr1)
//Promise。如果传入普通的值，就会使用Promise.resolve()包裹成promise
Promise.all()
Promise.race()

自定义类的迭代

在前面我们看到 Array、Set、String、Map 等类创建出来的对象都是可迭代对象：

在面向对象开发中，我们可以通过 class 定义一个自己的类，这个类可以创建很多的对象：
如果我们也希望自己的类创建出来的对象默认是可迭代的，那么在设计类的时候我们就可以添加上@@iterator 方法；

案例：创建一个 classroom 的类

教室中有自己的位置、名称、当前教室的学生；
这个教室可以进来新学生（push）；
创建的教室对象是可迭代对象；

//创建一个教室类，创建出来的对象都是可迭代对象
class Classroom {
  constructor(address, name, students) {
    this.address = address
    this.name = name
    this.students = students
  }
  entry(newStudent) {
    this.students.push(newStudent)
  }
  [Symbol.iterator]() {
    let index = 0
    return {
      next: () => {
        if (index < this.students.length) {
          return { done: false, value: this.students[index++] }
        } else {
          return { done: true, value: undefined }
        }
      }
    }
  }
}
const classroom = new Classroom('3楼', '计算机教室', ['a', 'b', 'c'])
classroom.entry('d')
for (const item of classroom) {
  console.log(item)
}

迭代器的中断

迭代器在某些情况下会在没有完全迭代的情况下中断：

比如遍历的过程中通过 break、continue、return、throw 中断了循环操作；
比如在解构的时候，没有解构所有的值；

那么这个时候我们想要监听中断的话，可以添加 return 方法：

23_Iterator-Generator - 图2

什么是生成器

生成器介绍

生成器是 ES6 中新增的一种函数控制、使用的方案，它可以让我们更加灵活的控制函数什么时候继续执行、暂停执行等。
平时我们会编写很多的函数，这些函数终止的条件通常是返回值或者发生了异常。

生成器函数也是一个函数，但是和普通的函数有一些区别：

首先，生成器函数需要在 function 的后面加一个符号：*
其次，生成器函数可以通过 yield 关键字来控制函数的执行流程：
最后，生成器函数的返回值是一个 Generator（生成器）：
- 生成器事实上是一种特殊的迭代器；
- MDN：Instead, they return a special type of iterator, called a Generator

生成器函数执行

我们发现上面的生成器函数 foo 的执行体压根没有执行，它只是返回了一个生成器对象。

那么我们如何可以让它执行函数中的东西呢？调用 next 即可；

function* foo() {
  console.log('函数开始执行～')
  const value1 = 100
  console.log('第一段', value1)
  yield
  const value2 = 200
  console.log('第二段', value2)
  yield
  const value3 = 300
  console.log('第三段', value3)
  yield
  console.log('函数执行结束')
}
//这样子调用函数时，会返回生成器对象
const generator = foo()
//开始执行第一段代码
generator.next()
//开始执行第二段代码
generator.next()
//开始执行第三段代码
generator.next()
//开始执行第四段代码
generator.next()

我们之前学习迭代器时，知道迭代器的 next 是会有返回值的；
但是我们很多时候不希望 next 返回的是一个 undefined，这个时候我们可以通过 yield 来返回结果；

//当遇到yield是暂停执行。当遇到return，是停止执行
function* foo() {
  console.log('函数开始执行～')
  const value1 = 100
  console.log('第一段', value1)
  yield value1
  const value2 = 200
  console.log('第二段', value2)
  yield value2
  const value3 = 300
  console.log('第三段', value3)
  yield value3
  console.log('函数执行结束')
  return '123'
}
//这样子调用函数时，会返回生成器对象
const generator = foo()
//开始执行第一段代码
console.log(generator.next())
//开始执行第二段代码
console.log(generator.next())
//开始执行第三段代码
console.log(generator.next())
//开始执行第四段代码
console.log(generator.next())
// 运行结果
// 函数开始执行～
// 第一段 100
// { value: 100, done: false }
// 第二段 200
// { value: 200, done: false }
// 第三段 300
// { value: 300, done: false }
// 函数执行结束
// { value: '123', done: true }

生成器传递参数

函数既然可以暂停来分段执行，那么函数应该是可以传递参数的，我们是否可以给每个分段来传递参数呢？

答案是可以的；
我们在调用 next 函数的时候，可以给它传递参数，那么这个参数会作为上一个 yield 语句的返回值；
注意：也就是说我们是为本次的函数代码块执行提供了一个值；

23_Iterator-Generator - 图3

生成器提前结束

return 函数

还有一个可以给生成器函数传递参数的方法是通过 return 函数：

return 传值后这个生成器函数就会结束，之后调用 next 不会继续生成值了；

//当遇到yield是暂停执行。当遇到return，是停止执行
function* foo(num) {
  console.log('函数开始执行～')
  const value1 = 100 * num
  console.log('第一段', value1)
  const n = yield value1
  const value2 = 200 * n
  console.log('第二段', value2)
  const m = yield value2
  const value3 = 300 * m
  console.log('第三段', value3)
  yield value3
  console.log('函数执行结束')
  return '123'
}
//这样子调用函数时，会返回生成器对象
const generator = foo(5)
//开始执行第一段代码
console.log(generator.next())
console.log(generator.return(15))
// 运行结果
// 函数开始执行～
// 第一段 500
// { value: 500, done: false }
// { value: 15, done: true }

生成器抛出异常

除了给生成器函数内部传递参数之外，也可以给生成器函数内部抛出异常：

抛出异常后我们可以在生成器函数中捕获异常；
但是在 catch 语句中不能继续 yield 新的值了，但是可以在 catch 语句外使用 yield 继续中断函数的执行；

function* foo() {
  console.log('函数开始执行～')
  const value1 = 100
  console.log('第一段', value1)
  try {
    yield value1
  } catch (error) {
    console.log('捕获异常', error)
  }
  const value2 = 200
  console.log('第二段', value2)
  const m = yield value2
  const value3 = 300 * m
  console.log('第三段', value3)
  yield value3
  console.log('函数执行结束')
  return '123'
}
//这样子调用函数时，会返回生成器对象
const generator = foo()
//开始执行第一段代码
console.log(generator.next())
console.log(generator.throw('error message'))
// 运行结果======================
// 函数开始执行～
// 第一段 100
// { value: 100, done: false }
// 捕获异常 error message
// 第二段 200
// { value: 200, done: false }

生成器替代迭代器

我们发现生成器是一种特殊的迭代器，那么在某些情况下我们可以使用生成器来替代迭代器；

// 生成器替代迭代器
function* createArrayIterator(array) {
  for (const item of array) {
    yield item
  }
}
const names = ['abc', 'bcd', 'cde']
const namesIterator = createArrayIterator(names)
console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())
// 运行结果
// { value: 'abc', done: false }
// { value: 'bcd', done: false }
// { value: 'cde', done: false }
// { value: undefined, done: true }

事实上我们还可以使用 yield*来生产一个可迭代对象：

这个时候相当于是一种 yield 的语法糖，只不过会依次迭代这个可迭代对象，每次迭代其中的一个值；

// 生成器替代迭代器
function* createArrayIterator(array) {
  yield* array
}
const names = ['abc', 'bcd', 'cde']
const namesIterator = createArrayIterator(names)
console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())
// 运行结果
// { value: 'abc', done: false }
// { value: 'bcd', done: false }
// { value: 'cde', done: false }
// { value: undefined, done: true }

案例 2:创建一个函数，这个函数可以迭代一个范围内的数字

当我们使用迭代器的时候

function createRangeIterator(start, end) {
  let index = start
  return {
    next: function () {
      if (start < end) {
        return { done: false, value: index++ }
      } else {
        return { done: true, value: undefined }
      }
    }
  }
}
const rangeIterator = createRangeIterator(10, 20)
console.log(rangeIterator.next())
console.log(rangeIterator.next())
console.log(rangeIterator.next())
console.log(rangeIterator.next())

当我们使用生成器替代迭代器

function* createRangeIterator(start, end) {
  for (let i = start; i < end; i++) {
    yield i
  }
}
const rangeIterator = createRangeIterator(10, 20)
console.log(rangeIterator.next())
console.log(rangeIterator.next())
console.log(rangeIterator.next())
console.log(rangeIterator.next())

案例 3:在之前的自定义类迭代中，我们也可以换成生成器：

//创建一个教室类，创建出来的对象都是可迭代对象
class Classroom {
  constructor(address, name, students) {
    this.address = address
    this.name = name
    this.students = students
  }
  entry(newStudent) {
    this.students.push(newStudent)
  }
  *[Symbol.iterator]() {
    yield* this.students
  }
}
//测试代码===============================================================
const classroom = new Classroom('3楼', '计算机教室', ['a', 'b', 'c'])
classroom.entry('d')
for (const item of classroom) {
  console.log(item)
  if (item == 'c') {
    break //调用return()
  }
}

23_Iterator-Generator - 图4

异步处理方案

学完了我们前面的 Promise、生成器等，我们目前来看一下异步代码的最终处理方案。

在 Promise 章节中，我们对网络请求是这样子做的(模拟网络请求)

function requestData(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      //拿到请求的结果
      resolve(url)
    }, 2000)
  })
}
const promise = requestData('why')
promise.then(
  (res) => {
    console.log(res)
  },
  (err) => {
    console.log(err)
  }
)

现在，我们要提出新的需求

我们需要向服务器发送网络请求获取数据，一共需要发送三次请求；
第二次的请求 url 依赖于第一次的结果；
第三次的请求 url 依赖于第二次的结果；
依次类推…

解决

第一种方案

function requestData(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      //拿到请求的结果
      resolve(url)
    }, 2000)
  })
}
//会产生回调地狱
requestData('why').then((res) => {
  requestData(res + 'aaa').then((res) => {
    requestData(res + 'bbb').then((res) => {
      console.log(res)
    })
  })
})

第二种方案

function requestData(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      //拿到请求的结果
      resolve(url)
    }, 2000)
  })
}
//使用Promise的返回值,代码阅读性不好
requestData('why')
  .then((res) => {
    return requestData(res + 'aaa')
  })
  .then((res) => {
    return requestData(res + 'bbb')
  })
  .then((res) => {
    console.log(res)
  })

第三种方案

// 第三种方案 Promise+generator
function* getData() {
  const res1 = yield requestData('why')
  const res2 = yield requestData(res1 + 'bbb')
  const res3 = yield requestData(res2 + 'aaa')
  console.log(res3)
}
const generator = getData()
generator.next().value.then((res) => {
  generator.next(res).value.then((res) => {
    generator.next(res).value.then((res) => {
      generator.next(res)
    })
  })
})

我们可以封装

function* getData() {
  const res1 = yield requestData('why')
  const res2 = yield requestData(res1 + 'bbb')
  const res3 = yield requestData(res2 + 'ccc')
  console.log(res3)
}
function execGenerator(genFn) {
  const generator = genFn()
  function exec(res) {
    const result = generator.next(res)
    if (result.done) {
      return result.value
    }
    result.value.then((res) => {
      exec(res)
    })
  }
  exec()
}
execGenerator(getData)

然后还有 TJ 写的 co

function requestData(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      //拿到请求的结果
      resolve(url)
    }, 2000)
  })
}
function* getData() {
  const res1 = yield requestData('why')
  const res2 = yield requestData(res1 + 'bbb')
  const res3 = yield requestData(res2 + 'ccc')
  console.log(res3)
}
const co = require('co')
co(getData)

第四种方案 async/await

function requestData(url) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      //拿到请求的结果
      resolve(url)
    }, 2000)
  })
}
async function getData() {
  const res1 = await requestData('why')
  const res2 = await requestData(res1 + 'bbb')
  const res3 = await requestData(res2 + 'ccc')
  console.log(res3)
}
getData()