迭代器
什么是迭代器?
迭代器(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的语法糖,只不过会依次迭代这个可迭代对象,每次迭代其中的一个值