跟着coderwhy学习
1.什么是迭代器？
- 迭代器（iterator），是确使用户可在容器对象（container，例如链表或数组）上遍访的对象，使用该接口无需关心对象的内部实现细节。
- 其行为像数据库中的光标，迭代器最早出现在1974年设计的CLU编程语言中；
- 在各种编程语言的实现中，迭代器的实现方式各不相同，但是基本都有迭代器，比如Java、Python等；
- 从迭代器的定义我们可以看出来，迭代器是帮助我们对某个数据结构进行遍历的对象。
- 在JavaScript中，迭代器也是一个具体的对象，这个对象需要符合迭代器协议（iterator protocol）：
- 迭代器协议定义了产生一系列值（无论是有限还是无限个）的标准方式；
- 那么在js中这个标准就是一个特定的next方法；
- next方法有如下的要求：
- 一个无参数或者一个参数的函数，返回一个应当拥有以下两个属性的对象：
- done（boolean）
- 如果迭代器可以产生序列中的下一个值，则为 false。（这等价于没有指定 done 这个属性。）
- 如果迭代器已将序列迭代完毕，则为 true。这种情况下，value 是可选的，如果它依然存在，即为迭代结束00之后的默认返回值。
- value
- 迭代器返回的任何 JavaScript 值。done 为 true 时可省略。
2.迭代器的代码练习
// 创建一个无限的迭代器
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())
3.可迭代对象
- 但是上面的代码整体来说看起来是有点奇怪的：
- 我们获取一个数组的时候，需要自己创建一个index变量，再创建一个所谓的迭代器对象；
- 事实上我们可以对上面的代码进行进一步的封装，让其变成一个可迭代对象；
- 什么又是可迭代对象呢？
- 它和迭代器是不同的概念；
- 当一个对象实现了iterable protocol协议时，它就是一个可迭代对象；
- 这个对象的要求是必须实现 @@iterator 方法，在代码中我们使用 Symbol.iterator 访问该属性；
- 当我们要问一个问题，我们转成这样的一个东西有什么好处呢？
- 当一个对象变成一个可迭代对象的时候，进行某些迭代操作，比如 for...of 操作时，其实就会调用它的@@iterator 方法；
4.可迭代对象的代码
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 }
}
}
}
}
}
5.原生迭代器对象
- 事实上我们平时创建的很多原生对象已经实现了可迭代协议，会生成一个迭代器对象的：
- String、Array、Map、Set、arguments对象、NodeList集合；
const names = ['abc', 'cba', 'nba']
console.log(names[Symbol.iterator]); // [Function: values]
// const iterator1 = names[Symbol.iterator]()
// console.log(iterator1.next())
// console.log(iterator1.next())
// console.log(iterator1.next())
// console.log(iterator1.next())
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)
6.可迭代对象的应用
- 那么这些东西可以被用在哪里呢？
- JavaScript中语法：for ...of、展开语法（spread syntax）、yield、解构赋值（Destructuring_assignment）；
- 创建一些对象时：new Map([Iterable])、new WeakMap([iterable])、new Set([iterable])、new WeakSet([iterable]);
- 一些方法的调用：Promise.all(iterable)、Promise.race(iterable)、Array.from(iterable);
// for (const item of obj) {
// }
// ES9(ES2018)中新增的一个特性: 用的不是迭代器
const newObj = { ...obj }
console.log(newObj) //{ name: 'mint', age: 18 }
// 3.解构语法
const [ name1, name2 ] = names
// const { name, age } = obj 不一样ES9新增的特性
// 4.创建一些其他对象时
const set1 = new Set(iterableObj)
const set2 = new Set(names)
const arr1 = Array.from(iterableObj)
// 5.Promise.all
Promise.all(iterableObj).then(res => {
console.log(res) //[ 'abc', 'cba', 'nba' ]
})
7.自定义类的迭代
- 在前面我们看到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 classroom1 = new Classroomm('1001', '1幢'， ['abc', 'cba']) const classroom2 = new Classroomm('2002', '2幢'， ['mint', 'pika']) for (const stu of classroom1) { console.log(stu) } for (const stu of classroom2) { console.log(stu) }
8.迭代器的中断
- 迭代器在某些情况下会在没有完全迭代的情况下中断：
- 比如遍历的过程中通过break、continue、return、throw中断了循环操作；
- 比如在解构的时候，没有解构所有的值；
- 那么这个时候我们想要监听中断的话，可以添加return方法：
[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 }
}
},
return: () => {
console.log("迭代器提前终止了~")
return { done: true, value: undefined }
}
}
}
for (const stu of classroom) {
console.log(stu)
if (stu === "abc") break
}
8.什么是生成器？
- 生成器是ES6中新增的一种函数控制、使用的方案，它可以让我们更加灵活的控制函数什么时候继续执行、暂停执行等。
- 平时我们会编写很多的函数，这些函数终止的条件通常是返回值或者发生了异常。
- 生成器函数也是一个函数，但是和普通的函数有一些区别：
- 首先，生成器函数需要在function的后面加一个符号：*
- 其次，生成器函数可以通过yield关键字来控制函数的执行流程：
- 最后，生成器函数的返回值是一个Generator（生成器）：
- 生成器事实上是一种特殊的迭代器；
- MDN：Instead, they return a special type of iterator, called a Generator.
9.生成器函数执行
- 发现上面的生成器函数foo的执行体压根没有执行，它只是返回了一个生成器对象。
- 那么我们如何可以让它执行函数中的东西呢？调用next即可；
- 我们之前学习迭代器时，知道迭代器的next是会有返回值的；
- 但是我们很多时候不希望next返回的是一个undefined，这个时候我们可以通过yield来返回结果；
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()
// 执行到第一个yield，并且暂停
console.log(generator.next()) // { value: undefined, done: false }
// 执行到第二个yield，并且暂停
console.log(generator.next())
// 执行到第三个yield，并且暂停
console.log(generator.next())
// 执行剩余代码
console.log(generator.next())
10.生成器传递参数 – next函数
- 函数既然可以暂停来分段执行，那么函数应该是可以传递参数的，我们是否可以给每个分段来传递参数呢？
- 答案是可以的；
- 我们在调用next函数的时候，可以给它传递参数，那么这个参数会作为上一个yield语句的返回值；
- 注意：也就是说我们是为本次的函数代码块执行提供了一个值；
function* foo(num) { console.log("函数开始执行~") const value1 = 100 * num console.log("第一段代码:", value1) const n = yield value1 const value2 = 200 * n console.log("第二段代码:", value2) const count = yield value2 const value3 = 300 * count console.log("第三段代码:", value3) yield value3 console.log("函数执行结束~") return "123" } // 生成器上的next方法可以传递参数 const generator = foo(5) console.log(generator.next()) // 第二段代码, 第二次调用next的时候执行的 console.log(generator.next(10)) console.log(generator.next(25))
11.生成器提前结束 – return函数
还有一个可以给生成器函数传递参数的方法是通过return函数： preturn传值后这个生成器函数就会结束，之后调用next不会继续生成值了；
function* foo(num) {
console.log("函数开始执行~")
const value1 = 100 * num
console.log("第一段代码:", value1)
const n = yield value1
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(10)
console.log(generator.next()) //{ value: 1000, done: false }
// 第二段代码的执行, 使用了return
// 那么就意味着相当于在第一段代码的后面加上return, 就会提前终端生成器函数代码继续执行
console.log(generator.return(15)) // { value: 15, done: true }
console.log(generator.next()) // { value: undefined, done: true }
console.log(generator.next()) // { value: undefined, done: true }
console.log(generator.next()) // ...
console.log(generator.next())
console.log(generator.next())
console.log(generator.next())
12.生成器抛出异常 – throw函数
- 除了给生成器函数内部传递参数之外，也可以给生成器函数内部抛出异常：
- 抛出异常后我们可以在生成器函数中捕获异常；
- 但是在catch语句中不能继续yield新的值了，但是可以在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() const result = generator.next() generator.throw("error message")
13.生成器替代迭代器
- 我们发现生成器是一种特殊的迭代器，那么在某些情况下我们可以使用生成器来替代迭代器：
// 1.生成器来替代迭代器
function* createArrayIterator(arr) {
// 2.第二种写法
for (const item of arr) {
yield item
}
// 1.第一种写法 low
// yield "abc" // { done: false, value: "abc" }
// yield "cba" // { done: false, value: "abc" }
// yield "nba" // { done: false, value: "abc" }
}
const names = ["abc", "cba", "nba"]
const namesIterator = createArrayIterator(names)
// 2.创建一个函数, 这个函数可以迭代一个范围内的数字
function* createRangeIterator(start, end) {
let index = start
while (index < end) {
yield index++
}
}
- 事实上我们还可以使用
yield*来生产一个可迭代对象：- 这个时候相当于是一种yield的语法糖，只不过会依次迭代这个可迭代对象，每次迭代其中的一个值；
function* createArrayIterator(arr) { yield* arr }
14.自定义类迭代 – 生成器实现
- 在之前的自定义类迭代中，我们也可以换成生成器：
class Classroom {
constructor(address, name, students) {
this.address = address
this.name = name
this.students = students
}
entry(newStudent) {
this.students.push(newStudent)
}
foo = () => {
console.log("foo function")
}
// [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)
}
15.对生成器的操作
const namesIterator1 = createArrayIterator(names)
for (const item of namesIterator1) {
console.log(item)
}
const namesIterator2 = createArrayIterator(names)
const set = new Set(namesIterator2)
console.log(set)
const namesIterator3 = createArrayIterator(names)
Promise.all(namesIterator3).then(res => {
console.log(res)
})
16.异步处理方案
-
前面的Promise、生成器等，我们目前来看一下异步代码的最终处理方案。
-
需求：
- 我们需要向服务器发送网络请求获取数据，一共需要发送三次请求；
- 第二次的请求url依赖于第一次的结果；
- 第三次的请求url依赖于第二次的结果；
- 依次类推；
-
request.js
function requestData(url) {
// 异步请求的代码会被放入到executor中
return new Promise((resolve, reject) => {
// 模拟网络请求
setTimeout(() => {
// 拿到请求的结果
resolve(url)
}, 2000);
})
}
- 1.第一种方案: 多次回调
// 回调地狱
requestData("mint").then(res => {
requestData(res + "aaa").then(res => {
requestData(res + "bbb").then(res => {
console.log(res)
})
})
})
}
- 2.第二种方案: Promise中then的返回值来解决
requestData('mint').then(res => {
return requestData(res + "aaa")
}).then(res => {
return requestData(res + "bbb")
}).then(res => {
console.log(res)
})
}
17.Generator方案
-
但是上面的代码其实看起来也是阅读性比较差的，有没有办法可以继续来对上面的代码进行优化呢？
-
3.第三种方案: Promise + generator 实现
function* getData() {
const res1 = yield requestData("mint")
const res2 = yield requestData(res1 + "aaa")
const res3 = yield requestData(res2 + "bbb")
const res4 = yield requestData(res3 + "ccc")
console.log(res4)
}
const generator = getData()
generator.next().value.then(res => {
generator.next(res).value.then(res => {
generator.next(res).value.then(res => {
generator.next(res)
})
})
})
18.自动执行generator函数
- 目前我们的写法有两个问题：
- 第一，我们不能确定到底需要调用几层的Promise关系；
- 第二，如果还有其他需要这样执行的函数，我们应该如何操作呢？
- 所以，我们可以封装一个工具函数execGenerator自动执行生成器函数：
function exeGenerator(getFn) {
const generator = getFn()
function exec(res) {
const result = generator.next(res)
if (result.done) {
return result.value
}
result.value.then(res => {
exec(res)
})
}
exec()
}
