迭代器
什么是迭代器？
迭代器（iterator），是确使用户可在容器对象(container，例如链表或数组)上遍访的对象，使用该接口无需关系对象的内部实现细节。
其行为像数据库中的光标，迭代器最早出现在1974年设计的CLU编程语言中；
在各种编程语言的实现中，迭代器的实现方式各不相同，但是基本都有迭代器，比如Java，Python等；
在迭代器的定义我们可以看出来，迭代器是帮助我们对某个数据结构进行遍历的对象
在Javascript中，迭代器也是一个具体的对象，这个对象需要符合迭代器协议(iterator protocol);
迭代器协议定义了产生一系列值(无论是有限还是无限个) 的标准方式；
那么在js中这个标准就是一个特定的next方法；
next方法有如下的要求：
一个无参数或者一个参数的函数，返回一个应当拥有以下两个属性的对象：
done（boolean）
- 如果迭代器可以产生序列中的下一个值，则为false。(这等价于没有指定done这个属性)
- 如果迭代器已将序列迭代完毕，则为true。这种情况下，value是可选的，如果它依然存在，即为迭代结束之后的默认返回值。
value
迭代器返回的任何JavaScript值。done为true时可省略。
const iterator = {
//有next
next:function (){
//有返回值
return {
done:true,
value:'aaa'
}
}
}
迭代器的代码练习：
// 数组
const array = ['abc', 'bcd', 'dba']
// 创建一个迭代器来遍历数组
let index = 0
const namesIterator = {
next() {
if(index < array.length){
return {
done:false, value:array[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())
结果：
可迭代对象
它和当前是不同的概念；
当一个对象实现了iterable protocol协议(可迭代协议)时，它就是一个可迭代对象；
这个对象的要求是必须实现 @@iterator方法，在代码中我们使用Symbol.iterator访问该属性；
那么可迭代对象有什么好处呢？
当一个对象变成一个可迭代对象时，进行某些迭代操作，比如for…of操作时，其实就会调用它的@@iterator方法
可迭代对象代码：
const iteratorObj = {
names: ['abc', 'cef', 'fed'],
[Symbol.iterator]() {
let index = 0
return {
next:() => {
if (index < this.names.length) {
return {
done: false, value: this.names[index++] }
} else {
return {
done: true, value: undefined }
}
}
}
}
}
const iterator = iteratorObj[Symbol.iterator]()
console.log(iterator.next())
当我们用for…of方法去遍历上面这段代码时(可迭代对象)就会遍历出来
for(let iterators of iteratorObj) {
console.log(iterators) //可以使用for ... of()
}
结果：
而我们对普通对象进行for…of遍历时是会报错的
// for...of
const obj = {
name:'ljb',
age:18
}
// 这里的obj就不能使用for..of 因为它不是一个可迭代对象
for(let item of obj) {
console.log(item) // 报错：TypeError: obj is not iterable (可迭代的)
}
原生迭代器对象
JS本身就有内置的迭代器对象：
String、Array、Map、Set、arguments对象，NodeList集合；
const names = ['abc', 'cdf', 'fgd'] //字面量
for(let item of names ){
console.log(item)
}
可迭代对象的应用
1.Javascript中语法：for … of 、展开语法(spread syntax) 、yield*、解构赋值(Destructuring_assignment);
2.创建一些对象时：new Map([Iterable])、new WeakMap([iterable])、new Set([iterable])、new WeakSet([iterable]);
3.一些方法的调用：Promise.all(iterable)、Promise.race(iterable)、Array.from(iterable);
const iteratorObj = {
names: ['abc', 'dbc', 'def'],
[Symbol.iterator]() {
let index = 0
return {
next: () => {
if (index < this.names.length) {
return {
done: false, value: this.names[index++] }
} else {
return {
done: true, value: undefined }
}
}
}
}
}
const arr = [10, 20, 30, 40, 40]
const newArr = [...arr,...iteratorObj]
自定义类的迭代
在上面Array，Set、String、Map等类创建出来的对象都是可迭代对象
在面向对象开发中，我们可以通过class定义一个自己的类，这个类可以创建很多的对象
如果我们也希望自己的类创建出来的对象默认是可迭代的，那么在设计类的时候我们可以添加上@@iterator方法；
class Classroom {
constructor(adddress, name, students) {
this.adddress = adddress
this.name = name
this.students = students
}
[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('重庆', '计算机教室', ['jack', 'Tom', 'curry'])
for(let item of classroom) {
console.log(item)
}
迭代器的中断
迭代器在某些情况下会在没有完全迭代的情况下中断：
比如遍历的过程中通过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 }
}
}
}
for(let item of classroom) {
console.log(item)
if(item === 'Tom') break
}
结果：
生成器
什么是生成器？
生成器是ES6中新增的一种函数控制，使用的方案，它可以让我们更加灵活的控制函数什么时候继续执行、暂停执行等。
生成器函数也是一个函数，但是和普通函数有一些区别：
首先，生成器函数需要在function的后面加一个符号：*
其次，生成器函数可以通过yield关键字来控制函数的执行流程：
最后，生成器函数的返回值是一个Generator(生成器)：
- 生成器事实上是一种特殊的迭代器；
- MDN：Instead，they return a special type of iterator,called a Generator
生成器函数执行
我们如何让它执行函数中的东西呢？调用next即可；
迭代器的next是会有返回值的
但是我们很多时候不希望next返回的是一个undefined，这个时候我们就可以通过yield来返回结果：
function* foo() {
const value1 = 10
console.log(value1)
yield value1
const value2 = 20
console.log(value2)
const value3 = 30
console.log(value3)
yield value2
console.log('函数执行结束~')
}
const genertor = foo()
console.log(genertor.next())
console.log(genertor.next())
结果：
生成器传递参数-next函数
函数既然可以暂停来分段执行，那么函数应该是可以传递参数的，我们是否可以给每个分段来传递参数呢？
那肯定是可以的；
我们在调用next函数的时候，可以给它传递参数，那么这个参数会作为上一个yield语句的返回值
注意：也就是说我们是为本次的函数代码块执行提供了一个值；
function* foo() {
const value1 = 10
console.log(value1)
const n = yield value1
const value2 = 20 + n
console.log(value2)
yield value2
const value3 = 30
console.log(value3)
yield value3
console.log('函数执行结束~')
}
const genertor = foo()
console.log(genertor.next())
console.log(genertor.next(100))
console.log(genertor.next())
console.log(genertor.next())
生成器提前结束-return函数
还有一个可以给生成器函数传递参数的方法就是提供return函数；
return函数传值后这个生成器函数就会结束，之后调用next不会继续生成值了；
function* foo() {
const value1 = yield 'aaa'
console.log('value1:',value1)
const value2 = yield value1
const value3 = yield value1
}
const generator = foo()
console.log(generator.next())
console.log(generator.return(123))
console.log(generator.next())
生成器替代迭代器
我们发现生成器是一种特殊的迭代器，那么在某些情况下我们可以使用生成器来代替迭代器：
// 生成器代替迭代器
function* createArrayIterator(arr) {
for(let item of arr) {
yield item
}
}
const names = ['abc', 'dbc', 'cdf']
const namesIterator = createArrayIterator(names)
console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())
console.log(namesIterator.next())
事实上我们还可以使用yield* 来生产一个可迭代对象：
这个时候相当于是一种yield的语法糖，只不过会依次迭代这个可迭代对象，每次迭代其中的一个值