Iterator迭代器-Generator生成器

cocoCola91667
58 阅读10分钟

什么是迭代器？

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

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

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

在JavaScript中，迭代器也是一个具体的对象，这个对象需要符合迭代器协议（iterator protocol），迭代器协议定义了产生一系列值（无论是有限还是无限个）的标准方式，那么在js中这个标准就是一个特定的next方法。

next方法有如下的要求：

一个无参数或者一个参数的函数，返回一个应当拥有以下两个属性的对象：

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

迭代器分为有限迭代器和无限迭代器，当一个迭代器的done永远不为true的时候，这个迭代器就是无限迭代器。

创建迭代器对象

// 数组
const names = ["abc", "cba", "nba"]

let index = 0

// 创建一个迭代器对象来访问数组
const namesIterator = {
  next: function() {
    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()) // { done: false, value: "nba" }
console.log(namesIterator.next()) // { done: true, value: undefined }
console.log(namesIterator.next()) // { done: true, value: undefined }
console.log(namesIterator.next()) // { done: true, value: undefined }
console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())

生成迭代器对象的函数

function createArrayIterator(arr) {
  let index = 0
  return {
    next: function() {
      if (index < arr.length) {
        return { done: false, value: arr[index++] }
      } else {
        return { done: true, value: undefined } 
      }
    }
  }
}

const names = ["abc", "cba", "nba"]
const nums = [10, 22, 33, 12]

const namesIterator = createArrayIterator(names)
console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())

const numsIterator = createArrayIterator(nums)
console.log(numsIterator.next())
console.log(numsIterator.next())
console.log(numsIterator.next())
console.log(numsIterator.next())

// 创建一个无限的迭代器
function createNumberIterator() {
  let index = 0
  return {
    next: function() {
      return { done: false, value: index++ }
    }
  }
}

const numberInterator = createNumberIterator()
console.log(numberInterator.next())
console.log(numberInterator.next())
console.log(numberInterator.next())
console.log(numberInterator.next())
console.log(numberInterator.next())
console.log(numberInterator.next())
console.log(numberInterator.next())
console.log(numberInterator.next())
console.log(numberInterator.next())
console.log(numberInterator.next())
console.log(numberInterator.next())
console.log(numberInterator.next())
console.log(numberInterator.next())

可迭代对象

但是上面的代码整体来说看起来是有点奇怪的，因为我们获取一个数组的时候，需要自己创建一个index变量，再创建一个所谓的迭代器对象，事实上我们可以对上面的代码进行进一步的封装，让其变成一个可迭代对象。

什么又是可迭代对象呢？

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

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

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

// 创建一个迭代器对象来访问数组
const iterableObj = {
  names: ["abc", "cba", "nba"],
  [Symbol.iterator]: function() {
    let index = 0
    return {
      // next函数要使用箭头函数，这样this才是info对象。
      next: () => {
        if (index < this.names.length) {
          return { done: false, value: this.names[index++] }
        } else {
          return { done: true, value: undefined }
        }
      }
    }
  }
}

// iterableObj对象就是一个可迭代对象
// console.log(iterableObj[Symbol.iterator])

// 调用iterableObj[Symbol.iterator]函数拿到迭代器
const iterator = iterableObj[Symbol.iterator]()
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())

// for...of遍历的东西必须是一个可迭代对象,如果直接使用forof遍历如下对象会报错,所以forof我们一般用来遍历数组
// const obj = {
//   name: "why",
//   age: 18
// }

// 这就不报错
for (const item of iterableObj) {
  console.log(item)
}

补充：for...of遍历的东西必须是一个可迭代对象，所以forof我们一般用来遍历数组，forof其实就是语法糖，它的本质就是一次一次调用迭代器，然后通过.value拿到迭代的值。

原生迭代器对象

事实上我们平时创建的很多原生对象已经实现了可迭代协议，会生成一个迭代器对象的，String、Array、Map、Set、arguments对象、NodeList集合。

const names = ["abc", "cba", "nba"]
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())

// 所以我们可以直接通过forof遍历数组
for (const item of names) {
  console.log(item)
}

// Map/Set也是可迭代对象
const set = new Set()
set.add(10)
set.add(100)
set.add(1000)

console.log(set[Symbol.iterator])

for (const item of set) {
  console.log(item)
}

// 函数中arguments也是一个可迭代对象
function foo(x, y, z) {
  console.log(arguments[Symbol.iterator])
  for (const arg of arguments) {
    console.log(arg)
  }
}

foo(10, 20, 30)

可迭代对象的应用

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

  • JavaScript中语法：for ...of、展开语法（spread syntax）、解构赋值（Destructuring_assignment）、yield（后面讲）；
  • 创建一些对象时, 传入一个可迭代对象：new Map([Iterable])、new WeakMap([iterable])、new Set([iterable])、new WeakSet([iterable]);
  • 一些方法的调用：Array.from(iterable)、Promise.all(iterable)、Promise.race(iterable);
// 1.for of场景

// 2.展开语法(spread syntax)
const iterableObj = {
  names: ["abc", "cba", "nba"],
  [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 names = ["abc", "cba", "nba"]
const newNames = [...names, ...iterableObj]
console.log(newNames) // ["abc", "cba", "nba", "abc", "cba", "nba"]


// 普通对象不能使用forof遍历,但是可以使用展开运算符
const obj = { name: "why", age: 18 }
// for (const item of obj) {
// }
// 这是ES9(ES2018)中新增的一个特性: 用的不是迭代器
const newObj = { ...obj }
console.log(newObj) // { name: "why", age: 18 }


// 3.解构语法
const [ name1, name2 ] = names // abc cba

// 如果是对象,也是ES9(ES2018)中新增的一个特性: 用的不是迭代器
// const { name, age } = obj 

// 4.创建一些其他对象时, 传入一个可迭代对象
const set1 = new Set(iterableObj)
const set2 = new Set(names)

// 5. 一些方法的调用
const arr1 = Array.from(iterableObj)

Promise.all(iterableObj).then(res => {
  console.log(res)
})

自定义类的可迭代性

在前面我们看到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 }
        }
      },
      // 2. 在return函数中监听迭代的终止,很少使用
      return: () => {
        console.log("迭代器提前终止了~")
        return { done: true, value: undefined }
      }
    }
  }
}

const classroom = new Classroom("3幢5楼205", "计算机教室", ["james", "kobe", "curry", "why"])
classroom.entry("lilei")

// 遍历教室
for (const stu of classroom) {
  console.log(stu)
  if (stu === "why") break //1. 使用break提前终止迭代
}


// 上面是用class封装的类, 如果是用构造函数封装的类,直接在其原型对象上添加方法就可以了
function Person() {
}

Person.prototype[Symbol.iterator] = function() {
}

迭代器的中断

迭代器在某些情况下会在没有完全迭代的情况下中断，比如遍历的过程中通过break、continue、return、throw中断了循环操作，比如在解构的时候，没有解构所有的值。那么这个时候我们想要监听中断的话，可以添加return方法。

什么是生成器函数？

生成器是ES6中新增的一种函数控制、使用的方案，它可以让我们更加灵活的控制函数什么时候继续执行、暂停执行等。

平时我们会编写很多的函数，这些函数终止的条件通常是return或者发生了异常。

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

  • 首先，生成器函数需要在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是会有返回值的，默认是undefined。但是我们很多时候不希望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"
}

// generator本质上是一个特殊的iterator
const generator = foo()
console.log("返回值1:", generator.next()) 
console.log("返回值2:", generator.next()) 
console.log("返回值3:", generator.next()) 
console.log("返回值3:", generator.next()) 

打印：
// 第一段代码：100
// 返回值1: {value: 100 , done: false}
// 第一段代码：200
// 返回值2: {value: 200 , done: false}
// 第一段代码：300
// 返回值3: {value: 300 , done: false}
// 函数执行结束~
// 返回值4: {value: 123 , done: true}

生成器的next传递参数

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

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

function* foo(num) {
  console.log("函数开始执行~")

  const value1 = 100 * num // 这里的num就是5
  console.log("第一段代码:", value1)
  const n = yield value1 

  const value2 = 200 * n // 这里的n是10
  console.log("第二段代码:", value2)
  const count = yield value2 

  const value3 = 300 * count // 这里的count是25
  console.log("第三段代码:", value3) 
  yield value3

  console.log("函数执行结束~")
  return "123"
}

// 生成器上的next方法可以传递参数
// 1. 第一段代码的参数是调用生成器函数的时候传入的
// 2. 其他段代码的参数是上一个yield的返回值

const generator = foo(5)
// 第一段代码
console.log(generator.next())
// 第二段代码
console.log(generator.next(10))
// 第三段代码
console.log(generator.next(25))


// 第一段代码：500
// {value: 500 , done: false}
// 第一段代码：2000
// {value: 2000 , done: false}
// 第一段代码：7500
// {value: 7500 , done: false}
// 函数执行结束~
// {value: 123 , done: true}

生成器的return终止执行

还有一个可以给生成器函数传递参数的方法是通过return函数，return传值后这个生成器函数就会结束，之后调用next不会继续生成值了；

function* foo(num) {
  console.log("函数开始执行~")

  const value1 = 100 * num
  console.log("第一段代码:", value1)
  const n = yield value1

  // return n    // 15

  const value2 = 200 * n
  console.log("第二段代码:", value2)
  const count = yield value2

  const value3 = 300 * count
  console.log("第三段代码:", value3)
  yield value3

  console.log("函数执行结束~")
  return "123"
}

const generator = foo(5)

console.log(generator.next())

// 第二段代码的执行, 使用了return
// 那么就意味着相当于在第一段代码的后面加上return, 就会提前终端生成器函数代码继续执行
console.log(generator.return(15))
console.log(generator.next())
console.log(generator.next())
console.log(generator.next())
console.log(generator.next())
console.log(generator.next())
console.log(generator.next())


// 第一段代码：500
// {value: 500 , done: false}
// {value: 15 , done: true}
// {value: undefined , done: true}
// {value: undefined , done: true}
// {value: undefined , done: true}
// {value: undefined , done: true}
// {value: undefined , done: true}

生成器的throw抛出异常

除了给生成器函数内部传递参数之外，也可以给生成器函数内部抛出异常，抛出异常后我们可以在生成器函数中捕获异常，我们可以在catch中继续yield新值，从而中断函数的继续执行。

function* foo() {
  console.log("代码开始执行~")

  const value1 = 100
  try {
    yield value1
  } catch (error) {
    console.log("捕获到异常情况:", error)

    yield "abc"
  }

  console.log("第二段代码继续执行")
  const value2 = 200
  yield value2

  console.log("代码执行结束~")
}

const generator = foo()

console.log(generator.next()) // 执行第一段代码
console.log(generator.throw("error message")) // 第一段代码会抛出异常

// 代码开始执行~
// {value: 100 , done: false}
// 捕获到异常情况: error message
// {value: abc  , done: false}

迭代器的return和throw方法使用的比较少，我们只要牢记next方法就行了。

生成器替代迭代器

生成器是一种特殊的迭代器，我们可以使用生成器来替代迭代器，这样代码更简洁。

案例一

原来我们的生成迭代器的函数是这样的：

function createArrayIterator(arr) {
  let index = 0
  return {
    next: function() {
      if (index < arr.length) {
        return { done: false, value: arr[index++] }
      } else {
        return { done: true, value: undefined } 
      }
    }
  }
}

const names = ["abc", "cba", "nba"]

const namesIterator = createArrayIterator(names)
console.log(namesIterator.next()) // {done: false, value: abc}
console.log(namesIterator.next()) // {done: false, value: cba}
console.log(namesIterator.next()) // {done: false, value: nba}
console.log(namesIterator.next()) // {done: true, value: undefined}

使用迭代器代替生成器有三种写法：

// 生成器来替代迭代器(记住function后面要加*)
function* createArrayIterator(arr) {

  // 3.第三种写法 yield* 后面跟着一个可迭代对象, 其实是第二种写法的语法糖
  // 会依次迭代这个可迭代对象，每次迭代其中的一个值；
  yield* arr

  // 2.第二种写法: 如果不希望使用index,可以直接遍历
  // for (const item of arr) {
  //   yield item
  // }

  // 1.第一种写法, 通过yield中断执行, 然后返回
  // let index = 0
  // yield arr[index++] 
  // yield arr[index++] 
  // yield arr[index++] 
}

const names = ["abc", "cba", "nba"]
const namesIterator = createArrayIterator(names)

console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())

打印结果和上面是一样的。

案例二

创建一个函数, 这个函数可以迭代一个范围内的数字。

// 创建一个函数, 这个函数可以迭代一个范围内的数字
// 10 20
function* createRangeIterator(start, end) {
  // 新的方式: 使用生成器(记住function后面要加*)
  let index = start
  while (index < end) {
    yield index++
  }

  // 旧的方式: 使用迭代器
  // let index = start
  // return {
  //   next: function() {
  //     if (index < end) {
  //       return { done: false, value: index++ }
  //     } else {
  //       return { done: true, value: undefined }
  //     }
  //   }
  // }
}

const rangeIterator = createRangeIterator(10, 20)
console.log(rangeIterator.next()) // {done: false, value: 10}
console.log(rangeIterator.next()) // {done: false, value: 11}
console.log(rangeIterator.next()) // {done: false, value: 12}
console.log(rangeIterator.next()) // {done: false, value: 13}
console.log(rangeIterator.next()) // {done: false, value: 14}
案例三

就是上面的classroom案例，原来的代码可参考classroom。使用生成器后的代码如下：

// class案例
class Classroom {
  constructor(address, name, students) {
    this.address = address
    this.name = name
    this.students = students
  }

  entry(newStudent) {
    this.students.push(newStudent)
  }

  // [Symbol.iterator] = function*() {
  //   yield* this.students
  // }

  *[Symbol.iterator]() {
    yield* this.students
  }
}

const classroom = new Classroom("3幢", "1102", ["abc", "cba"])
for (const item of classroom) {
  console.log(item)
}

可以发现，把迭代器换成生成器之后，代码会很简洁，所以一般我们能用生成器就使用生成器。

异步处理方案

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

需求：

  • 我们需要向服务器发送网络请求获取数据，一共需要发送三次请求；
  • 第二次的请求url依赖于第一次的结果；
  • 第三次的请求url依赖于第二次的结果；
  • 依此类推；
// 需求: 
// 1> url: why -> res: why
// 2> url: res + "aaa" -> res: whyaaa
// 3> url: res + "bbb" => res: whyaaabbb

// request.js
function requestData(url) {
  // 异步请求的代码会被放入到executor中
  return new Promise((resolve, reject) => {
    // 模拟网络请求
    setTimeout(() => {
      // 拿到请求的结果
      resolve(url)
    }, 2000);
  })
}

// 1.第一种方案: 多次回调
// 回调地狱
requestData("why").then(res => {
  requestData(res + "aaa").then(res => {
    requestData(res + "bbb").then(res => {
      console.log(res)
    })
  })
})

// 2.第二种方案: Promise中then的返回值来解决
requestData("why").then(res => {
  return requestData(res + "aaa")
}).then(res => {
  return requestData(res + "bbb")
}).then(res => {
  console.log(res)
})

Generator方案

但是上面的代码其实看起来也是阅读性比较差的，有没有办法可以继续来对上面的代码进行优化呢？

// 3.第三种方案: Promise + generator实现
function* getData() {
  const res1 = yield requestData("why")
  const res2 = yield requestData(res1 + "aaa")
  const res3 = yield requestData(res2 + "bbb")
  const res4 = yield requestData(res3 + "ccc")
  console.log(res4)
}

// 1> 手动执行生成器函数
const generator = getData()
generator.next().value.then(res => {
  generator.next(res).value.then(res => {
    generator.next(res).value.then(res => {
      generator.next(res)
    })
  })
})

上面代码我们将getData方法变成一个生成器函数，这样我们就能通过yield控制函数的分段执行，然后通过next函数传参，就能实现将上一次的结果给下一次网络请求使用。

自动执行generator函数

目前我们的写法有两个问题：

  • 第一，我们不能确定到底需要调用几层的Promise关系；
  • 第二，如果还有其他需要这样执行的函数，我们应该如何操作呢？

所以，我们可以封装一个工具函数execGenerator自动执行生成器函数。

// 2> 自己封装了一个自动执行的函数
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()
}

最终代码如下：

// request.js
function requestData(url) {
  // 异步请求的代码会被放入到executor中
  return new Promise((resolve, reject) => {
    // 模拟网络请求
    setTimeout(() => {
      // 拿到请求的结果
      resolve(url)
    }, 2000);
  })
}

// 3.第三种方案: Promise + generator实现
function* getData() {
  const res1 = yield requestData("why")
  const res2 = yield requestData(res1 + "aaa")
  const res3 = yield requestData(res2 + "bbb")
  const res4 = yield requestData(res3 + "ccc")
  console.log(res4)
}

// 递归调用函数
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)
// 打印：whyaaabbbccc

上面的自动执行函数是我们自己写的，其实npm上有这个自动执行函数的包，叫co，先安装：

npm install co

使用co：

const co = require('co')
co(getData)
// 打印：whyaaabbbccc

co这个包的作用就是让我们的生成器函数自动执行，co这个库是TJ写的，已经很久不维护了。

现在我们使用async、await方式，如下，是不是和我们的生成器函数很像，其实就是将*改成async，将yield改成await，其实async、await就是Promise + generator的语法糖。

// 4.第四种方案: async/await
async function getData() {
  const res1 = await requestData("why")
  const res2 = await requestData(res1 + "aaa")
  const res3 = await requestData(res2 + "bbb")
  const res4 = await requestData(res3 + "ccc")
  console.log(res4)
}

getData()
avatar
文章
阅读
粉丝