仓颉迭代器与惰性序列:从原理到手写实现
1. 从"能遍历"到"会偷懒":迭代器到底解决了什么问题
很多人第一次接触迭代器,脑子里冒出来的问题是"我直接用数组下标循环不就行了吗,为什么还要搞个迭代器出来"。这个问题问得特别好,因为它恰恰点到了迭代器存在的根本理由。如果你只是遍历一个长度已知、全部装在内存里的数组,那确实下标循环就够了,迭代器看起来像是多此一举。但真实工程里的数据形态远比这复杂:文件可能有几个G、数据库查询结果可能是几百万行、网络流可能永远不结束、某个序列的下一项需要经过复杂计算才能得到。这些场景下,你根本没办法"先把所有元素准备好再遍历",你需要的是"要一个、算一个、用一个"。
迭代器就是为这种"按需产出"而生的抽象。它把"遍历"这件事拆成了两个角色:一个是迭代器(Iterator),负责记住"我现在走到哪了",并且提供一个"给我下一个"的动作;另一个是可迭代对象(Iterable),负责回答"我能给你一个迭代器"。这个拆分看起来简单,但它带来的好处是连锁的。首先,遍历逻辑和数据结构解耦了,你的 for-in 循环不需要知道背后是数组、链表还是文件流,只要对方能给出迭代器就行。其次,状态被封装进了迭代器内部,多个遍历可以互不干扰地并行进行,各自持有各自的游标。最后,也是最重要的一点,它天然支持惰性求值——元素不是一开始就全部算好,而是在被请求时才计算。
仓颉语言在这套抽象上做得相当干净。它把 Iterable 和 Iterator 两个接口分得很清楚,Iterable 的核心能力是"能产出迭代器",Iterator 的核心能力是"能推进到下一项并取出当前项"。你在写 for (x in collection) 的时候,编译器实际上是在做一件事:先向 collection 要一个迭代器,然后反复调用迭代器的推进方法,每次拿到一个元素就绑定给 x,直到迭代器告诉你"没有了"。理解了这个展开过程,后面所有关于迭代器的技巧和坑,你都能自己推导出来。
这里有个特别值得强调的点:惰性序列。惰性序列是迭代器思想最迷人的产物。想象你要处理一个无限序列,比如自然数 1、2、3、4……一直下去。你不可能把它存进数组,但你可以用一个迭代器来描述它:每次被请求时返回当前值然后加一。这个迭代器本身只占几个字节,却能表示无穷多的元素。当你在这个无限序列上再叠加一层"只取前 100 个"或者"只取满足某条件的"操作时,整个链条依然是惰性的,直到你真正开始消费它,计算才会发生。这种"描述计算"和"执行计算"分离的能力,是迭代器最核心的价值,也是很多初学者容易忽略的地方。
我在实际项目里见过太多因为不理解惰性而写出的低效代码。比如有人写了一个"读取大文件每一行"的迭代器,然后在上面套了三层过滤和映射,最后用 for-in 遍历。这套写法本身没问题,但如果他在中间某一步不小心把迭代器转成了列表(比如调用了某个会强制求值的收集方法),那整个文件就会被一次性读进内存,惰性的好处瞬间归零。所以学迭代器,光会写 for-in 是不够的,你得时刻清楚"这一步到底有没有触发求值"。
2. Iterable 与 Iterator 的分工:为什么仓颉要把它们拆开
刚上手仓颉的时候,我一度觉得 Iterable 和 Iterator 分成两个接口有点啰嗦。毕竟在不少语言里,一个对象既是可迭代的又是迭代器本身,用起来好像更省事。但用久了之后我发现,仓颉这种拆分是有明确工程考量的,而且它逼着你去思考一个关键问题:"可被遍历"和"正在遍历"是两件不同的事。
Iterable 描述的是"这个东西可以被遍历"这个能力。它不持有遍历状态,它只是一个"迭代器工厂"。你每次向一个 Iterable 请求迭代器,都应该得到一个全新的、从头开始的迭代器。这就是为什么同一个列表可以被嵌套遍历两次而互不影响——外层循环和内层循环各自拿到的是独立的迭代器。如果 Iterable 和 Iterator 合二为一,那这个对象就同时承担了"数据源"和"游标"两个职责,一旦你开始遍历,这个对象的状态就被污染了,第二次遍历要么从头开始(丢失了第一次的进度语义),要么接着上次继续(这通常不是你想要的)。这种设计在简单场景下看不出问题,但在嵌套遍历、并发遍历、需要多次遍历同一数据源的场景下就会暴露出一堆难以调试的 bug。
Iterator 描述的是"一次具体的遍历过程"。它持有游标状态,知道当前走到哪了,并且提供推进的能力。仓颉里迭代器的典型形态是提供一个 next() 方法,它返回一个可选类型:有下一个元素时返回该元素,没有时返回空。这种"用可选类型表示结束"的设计比某些语言里抛异常表示结束要优雅得多,因为它把"正常结束"和"异常情况"区分开了——遍历到头是正常流程,不该用异常来表达。
我整理了一张表,把这两个角色的职责边界列清楚,你在设计自己的类型时可以对照着看:
| 维度 | Iterable(可迭代) | Iterator(迭代器) |
|---|---|---|
| 核心职责 | 产出迭代器 | 推进并取出元素 |
| 是否持有游标状态 | 不持有 | 持有 |
| 能否被多次遍历 | 能,每次给新迭代器 | 不能,一次性消费 |
| 典型方法 | 获取迭代器的方法 | 推进到下一项的方法 |
| 类比 | 一本书 | 一枚书签 |
| 生命周期 | 通常与数据源同寿 | 通常与一次遍历同寿 |
这个"书和书签"的类比我觉得特别贴切。书(Iterable)本身不记录你读到哪了,你可以拿多枚书签(Iterator)同时读同一本书的不同位置。书签(Iterator)记录的是"某一次阅读的进度",它是有状态的、一次性的。理解了这层关系,你就能明白为什么仓颉要拆开它们:状态应该被隔离在最小的生命周期里,这样才不会互相干扰。
在实际编码中,这个拆分带来的一个直接好处是:你可以放心地把 Iterable 作为参数传递,而不用担心"传进去之后对方遍历了,我这边就没法再遍历了"。因为对方拿到的是一个新的迭代器,你的数据源毫发无损。反过来,如果你拿到的是一个 Iterator,你就要意识到它是一次性的,遍历完就废了,想再遍历得重新从数据源要一个。这个认知差,是新手和老手在迭代器使用上最明显的分水岭。
还有一个容易被忽略的细节:一个类型可以同时实现 Iterable 和 Iterator,但这样做通常意味着它只能被遍历一次。仓颉允许你这么写,但你要清楚自己在做什么。我个人的经验是,除非你明确知道这个对象就是一次性的(比如一个网络流),否则不要让它同时承担两个角色,老老实实拆开,未来会省掉很多麻烦。
3. 手写一个迭代器:从"能跑"到"跑得对"的完整过程
光看接口定义是学不会迭代器的,必须自己动手写一个。我选一个既简单又能体现惰性价值的例子:斐波那契数列迭代器。斐波那契数列是 1、1、2、3、5、8、13……每一项是前两项之和,它是无限的,天然适合用迭代器来表达。我们一步步来,把"能跑"和"跑得对"之间的差距填上。
3.1 先想清楚状态该放在哪
写迭代器第一步不是写代码,是想清楚"我需要记住哪些状态"。斐波那契的下一项依赖前两项,所以迭代器内部至少要存两个数:当前项和下一项。每次推进时,把这两个数往后挪一格。初始状态是"还没产出任何项",此时前两项可以设为 1 和 1,这样第一次推进就能产出第一个 1。
这里有个设计决策:状态是放在迭代器里还是放在可迭代对象里?答案是必须放在迭代器里。因为可迭代对象可能被多次遍历,如果状态放在它里面,第二次遍历就会从上次的位置继续,这显然不对。所以正确的结构是:可迭代对象只存"起始参数"(比如从哪个数开始),迭代器存"当前进度"。
3.2 用可选类型表达"还有没有下一项"
仓颉的迭代器推进方法返回可选类型,这个设计我要专门夸一下。它强制你在写迭代器时明确回答一个问题:"什么时候算结束?"对于斐波那契这种无限序列,答案是"永远不结束",所以推进方法永远返回有值。但对于有限序列,你必须在某个时刻返回空,否则调用方会陷入死循环。
我见过有人写有限序列迭代器时,用"返回一个特殊值表示结束"的做法,比如返回 -1 表示没有了。这种做法在元素类型是整数时勉强能用,但如果元素本身就可能取 -1 呢?如果元素类型是字符串呢?用特殊值表示结束是脆弱的,可选类型才是正解。仓颉的可选类型让你在类型层面就把"可能没有"这件事表达出来,调用方必须处理空的情况,编译器会帮你把关。
3.3 一个完整的斐波那契迭代器长什么样
下面是我写的一个版本,结构上分两块:可迭代对象负责"造迭代器",迭代器负责"推进"。注意看状态是怎么在两者之间分配的。
这段代码有几个点值得展开说。第一,iterator() 方法每次返回新实例,这保证了多次遍历互不干扰。第二,迭代器里的 current 和 next 是 var,因为它们会变;而可迭代对象里的 startA 和 startB 是 let,因为它们一旦设定就不该变。这种"可变性最小化"的习惯能帮你避免很多并发和状态污染的问题。第三,next() 里先保存 result 再更新状态,顺序不能反,否则返回的就是更新后的值了。这种"先取后推"的顺序是迭代器实现的通用套路,写多了就成肌肉记忆了。
3.4 有限序列的结束判断怎么写才不出错
斐波那契是无限的,写起来简单。但真实场景里大多是有限序列,这时候"什么时候返回空"就成了最容易出错的地方。我拿"遍历一个整数列表"举例,说说常见的坑。
最直觉的写法是用一个下标变量,每次推进时判断下标是否越界。这个思路没错,但边界条件特别容易写错。比如列表长度为 0 时,第一次推进就该返回空;长度为 1 时,第一次返回元素,第二次返回空。我建议你在写完之后,专门用空列表、单元素列表、多元素列表三种情况各测一遍,这三个用例能覆盖绝大多数边界 bug。
还有一个更隐蔽的坑:迭代器被消费完之后再调用推进方法会怎样。理想情况下应该继续返回空,而不是崩溃或返回垃圾值。仓颉的迭代器协议期望你在结束后保持"返回空"的状态,所以你的实现里要保证"一旦结束,永远结束"。如果你的实现是"下标越界就返回空",那天然满足这个性质;但如果你用了某些会修改状态的写法,就要小心结束后状态被破坏。
提示:写有限序列迭代器时,把"是否结束"的判断放在推进方法的最开头,先判断再取值。这样即使被反复调用,也不会越界访问。
4. 惰性序列的威力:把"读整个文件"变成"读一行算一行"
迭代器最实用的价值,体现在处理大数据和流式数据上。我拿一个真实场景来讲:逐行处理一个超大日志文件,只保留包含特定关键字的行,并统计数量。如果用"先全部读进来再过滤"的写法,一个几 G 的文件直接能把内存撑爆。用迭代器把它改造成惰性流水线,内存占用可以稳定在常数级别。
4.1 惰性流水线的三段式结构
一条典型的惰性流水线由三部分组成:数据源、中间操作、终端操作。数据源负责产出原始元素(比如文件的每一行),中间操作负责变换和过滤(比如筛选含关键字的行、把行转成结构化对象),终端操作负责消费并产生最终结果(比如计数、求和、收集成列表)。关键在于:中间操作是惰性的,它们只是"记录"了要做什么,并不立即执行;只有终端操作被调用时,整条流水线才开始运转,而且是一个元素一个元素地流过所有中间操作,而不是一个操作处理完所有元素再交给下一个。
这个"逐元素流过"的模式有个专业叫法,叫拉取式(pull-based)。终端操作每要一个结果,就向最后一个中间操作要一个元素,最后一个中间操作再向前一个要,一路传到数据源。数据源产出一个元素,它沿着流水线一路被处理,最后被终端消费。处理完这一个,再拉下一个。整个过程内存里同时存在的元素通常只有一两个,这就是常数级内存占用的来源。
4.2 用迭代器封装文件行读取
仓颉里封装一个"逐行读取文件"的迭代器,核心思路是:迭代器内部持有文件句柄和"当前是否还有下一行"的状态,每次推进时读一行,读到文件尾就返回空。这里有个资源管理的细节要特别注意:文件句柄什么时候关闭。如果迭代器被提前中断(比如终端操作只取了前 10 行就停了),文件句柄必须也能被正确释放,否则会泄漏。
我的做法是把文件读取封装成一个可迭代对象,迭代器在构造时打开文件,在析构时关闭文件。仓颉的析构机制能保证对象被回收时执行清理逻辑,这样即使遍历中途退出,文件也能被关掉。如果你用的是需要显式关闭的资源,那就要在终端操作里用类似 try-finally 的结构保证关闭,或者依赖语言提供的自动资源管理语法。
注意 finished 这个标志位的作用:它保证文件只被关闭一次,并且结束后再调用推进方法会直接返回空,不会去碰已经关闭的句柄。这种"幂等结束"的设计是迭代器健壮性的关键。
4.3 中间操作为什么不能立即求值
现在假设我们要在 LineReader 上套一层"只保留含关键字的行"。如果这层过滤是立即求值的,那它就得把整个文件读一遍、把所有匹配的行存起来,惰性就没了。正确的做法是写一个过滤迭代器,它内部持有上游迭代器和过滤条件,每次推进时不断向上游要元素,直到找到一个满足条件的,或者上游耗尽。
这个 while(true) 循环是过滤迭代器的灵魂。它体现了惰性的本质:"我要一个满足条件的元素"这个请求,可能会触发上游产出多个元素。如果上游是无限的,而这个过滤条件永远不满足,那这个 next() 就会永远转下去——这是惰性序列的一个固有风险,后面我会专门讲怎么防。
4.4 把流水线串起来
有了数据源和中间操作,终端操作就简单了。统计数量无非是反复调用推进方法,数到空为止。整条流水线串起来大概是这样:
这段代码跑在一个几 G 的文件上,内存占用基本就是几个变量的开销。这就是惰性序列的威力:你用描述计算的方式,换来了常数级的内存占用。对比一下"先读全部再过滤"的写法,差距不是一点半点。
5. 惰性带来的新麻烦:那些只有踩过才知道的坑
惰性不是免费的午餐,它把一些原本简单的问题变复杂了。我在实际项目里踩过的坑,基本都集中在下面这几类。提前知道这些,能帮你省下大量调试时间。
5.1 无限序列遇上不满足的条件就是死循环
这是惰性序列最危险的坑。前面那个 FilterIterator,如果上游是无限序列,而过滤条件永远不满足,那 next() 就会永远转下去,程序卡死。更麻烦的是,这种卡死往往没有报错,就是 CPU 跑满、界面无响应,你盯着代码看半天也看不出问题在哪。
防御的办法有两个。第一个是在无限序列上永远不要用无界过滤,要么加一个"最多尝试 N 次"的限制,要么确保过滤条件最终一定会满足。第二个是用带截断的操作,比如"取前 100 个满足条件的",这样即使条件很苛刻,最多也就尝试有限次。仓颉的标准库如果提供了类似 take、takeWhile 这样的操作,优先用它们,它们内部会帮你处理边界。
我个人的习惯是:只要数据源可能是无限的,我在写过滤逻辑时就会问自己一句"如果所有元素都不满足,会发生什么"。如果答案是"死循环",那我就必须加限制。
5.2 迭代器被"消费两次"的隐蔽 bug
迭代器是一次性的,这个特性在简单场景下不会出问题,但在稍微复杂的逻辑里特别容易踩。举个我真实遇到的例子:有个同事写了个函数,接收一个迭代器,先遍历一遍统计总数,再遍历一遍找最大值。代码看起来人畜无害,但运行结果永远是"总数正确,最大值是第一个元素"。原因就是第一次遍历已经把迭代器消费完了,第二次遍历拿到的是空,最大值自然就停在初始值上。
这个 bug 的隐蔽之处在于它不报错,只是结果不对。防御的办法是:函数签名里如果接收的是 Iterator,就要意识到它是一次性的;如果调用方可能需要多次遍历,那参数类型应该是 Iterable,函数内部每次遍历时重新要一个迭代器。这个类型选择上的小差别,能避免一整类 bug。
5.3 惰性链条上的副作用执行时机
惰性求值会把副作用的执行时机推迟,这一点如果没意识到,会写出很反直觉的代码。比如你在中间操作里加了一句打印日志,你以为它在流水线构建时就执行了,实际上它要等到终端操作拉取元素时才执行,而且执行次数取决于终端拉了多少个。如果终端只取了前 10 个,那日志也只打印 10 次,而不是全部。
这个特性有时候是优点(避免不必要的计算),有时候是坑(你以为的日志没打出来)。我的建议是:惰性链条里尽量放纯函数,把副作用集中到终端操作。这样执行时机清晰,调试也方便。如果确实需要在中间操作里做副作用(比如记录处理进度),那就要清楚它的触发条件,别指望它一定会执行。
5.4 异常在惰性链条里怎么传播
惰性链条里抛异常,传播路径和立即求值不一样。在立即求值的代码里,异常在构建阶段就抛出来了;在惰性链条里,异常要等到终端操作拉取到那个出错的元素时才抛出。这意味着异常的抛出点可能离出错点很远,堆栈信息看起来会很奇怪。
处理办法是:在数据源和中间操作里对可能出错的地方做防御,把异常转成"跳过这个元素"或者"返回一个错误标记",而不是让它一路往上抛。如果确实需要让异常传播,那就在终端操作里统一捕获,并且记录足够的上下文(比如"处理到第几个元素时出错"),方便定位。
注意:惰性链条的调试难度普遍高于立即求值代码。如果你发现某个惰性流水线的行为不符合预期,最快的排查方法是在每个中间操作后面临时加一个"强制求值"的终端操作,把链条打断,看看每一步的输出是什么。定位到问题后再把临时操作去掉。
6. 迭代器与生成器:什么时候该用哪个
仓颉里除了手写迭代器,通常还提供生成器(generator)这种更轻量的写法。生成器让你用一个看起来像函数的语法,写出一个迭代器的行为,编译器帮你把状态管理、推进逻辑都生成好。很多人会问:既然有生成器,那还有必要手写迭代器吗?我的答案是:两者各有适用场景,选错了会给自己找麻烦。
生成器的优势在于写法简洁。你只需要在函数里用 yield 产出元素,函数的状态(局部变量、执行位置)会被自动保存,下次推进时从上次 yield 的地方继续。对于"逻辑比较线性"的序列,比如"遍历一棵树的中序结果"、"按某种规则生成一批数据",生成器写起来比手写迭代器短得多,也更不容易出错。你不用担心状态放哪、结束条件怎么写,编译器都帮你处理了。
但生成器也有它的局限。第一,生成器的状态是隐式的,你没法从外部检查"当前走到哪了",也没法在推进过程中插入自定义逻辑。如果你需要根据外部条件动态调整推进行为,生成器就力不从心了。第二,生成器的复用性较差,一个生成器函数调用一次产出一个迭代器,想复用逻辑得重新调用。第三,生成器的性能特征不透明,编译器生成的代码可能包含一些你意想不到的开销,在对性能极度敏感的场景下,手写迭代器能让你精确控制每一步。
我整理了一个选择参考:
| 场景 | 推荐方案 | 理由 |
|---|---|---|
| 逻辑线性的序列生成 | 生成器 | 写法简洁,状态自动管理 |
| 需要暴露游标状态 | 手写迭代器 | 状态显式可控 |
| 需要动态调整推进逻辑 | 手写迭代器 | 生成器无法插入外部逻辑 |
| 性能极度敏感 | 手写迭代器 | 可精确控制开销 |
| 一次性简单遍历 | 生成器 | 不值得为它写一个类 |
| 需要作为类型对外暴露 | 手写迭代器 | 接口清晰,可被依赖 |
还有一个折中方案:用生成器封装复杂逻辑,用迭代器接口对外暴露。也就是说,内部实现用生成器图个方便,但对外提供的类型实现 Iterable 接口,调用方看到的是一个标准的可迭代对象。这样既享受了生成器的简洁,又保持了接口的规范性。这个模式我在好几个项目里用过,效果很好。
需要提醒的是,生成器虽然方便,但不要用它来隐藏昂贵的计算。生成器的惰性特性意味着"看起来只是一行 yield,背后可能做了很重的活"。如果调用方不知道这一点,可能会在不经意间触发大量计算。我的习惯是:如果生成器里单次产出的计算成本较高,就在文档或注释里明确写出来,让调用方心里有数。
7. 把迭代器用进真实项目:几个我反复用到的模式
理论讲完了,最后分享几个我在实际项目里反复用到的迭代器模式。这些模式不是教科书上的标准答案,而是踩过坑之后沉淀下来的实用套路。
7.1 分页拉取模式
对接外部接口时,数据往往是分页返回的。与其在业务代码里写一堆"第几页、有没有下一页"的逻辑,不如封装成一个迭代器:迭代器内部记住当前页码和"是否还有下一页",每次推进时如果当前页还有数据就返回下一条,当前页用完了就自动拉下一页。这样业务代码只需要一个 for-in,完全不用关心分页细节。
这个模式的关键是把"翻页"这个动作藏在迭代器内部。业务方看到的是一个连续的序列,分页的边界被抹平了。实现时要注意:拉取下一页可能失败(网络问题),失败时是抛异常还是返回空,要根据业务语义决定。如果是"数据源就这么多",返回空;如果是"临时故障,重试可能成功",那应该抛异常让上层处理。
7.2 树形结构遍历模式
遍历树是迭代器的经典应用。树的遍历有前序、中序、后序、层序好几种,如果每种都写一个递归函数,代码会重复。用迭代器的话,可以把"遍历顺序"抽象出来:迭代器内部维护一个待访问节点的栈(或队列),每次推进时从栈里弹出一个节点,把它的子节点按顺序压进去,然后返回这个节点。换遍历顺序只需要换栈和队列,或者换压入子节点的顺序。
这个模式的好处是遍历逻辑和访问逻辑解耦。遍历顺序由迭代器决定,对每个节点做什么由调用方决定。调用方可以用同一个迭代器做不同的事,比如一次遍历收集所有节点、一次遍历查找特定节点,互不干扰。
7.3 批量加载模式
处理大批量数据时,逐条处理往往太慢(比如每条一次数据库往返),一次性全加载又太占内存。折中方案是批量加载:迭代器内部维护一个缓冲区,每次缓冲区空了就一次性加载一批(比如 1000 条),然后逐条从缓冲区返回。这样对上层来说还是逐条消费,但底层是批量操作,兼顾了内存和效率。
这个模式的实现要点是缓冲区大小要可配置,而且要根据实际场景调优。太小了批量优势不明显,太大了内存占用高。我一般会先设一个保守值(比如 500),然后根据实测的内存和耗时曲线调整。另外要注意最后一批可能不满,迭代器要能正确处理"缓冲区里不足一批但已经是最后一批"的情况。
这段骨架里,exhausted 标志位的作用是"数据源已经到底了,不用再尝试加载"。判断条件是"这一批不足 batchSize",因为只有最后一批才可能不满。这个判断逻辑简单有效,但要注意一个边界:如果数据源的总数恰好是 batchSize 的整数倍,那最后一批是满的,exhausted 不会被置位,下一次推进时会再加载一次,得到空批次,然后才返回空。这多了一次无用的加载,但结果正确。如果想优化掉这次多余加载,可以在加载到空批次时也置位 exhausted。
7.4 组合多个数据源
有时候数据来自多个源,需要按顺序拼接成一个序列。比如先读本地缓存,缓存没有再读远程。用迭代器实现的话,就是内部维护一个"当前数据源"的引用,当前源耗尽了就切换到下一个源。这个模式叫串联迭代器,实现起来不复杂,但能极大简化上层逻辑。
实现时要注意切换的时机:当前源返回空时,不要立即返回空,而是切换到下一个源再试。只有所有源都耗尽了,才返回空。这个"逐个尝试"的逻辑和前面过滤迭代器的 while 循环是同一个套路。
8. 关于迭代器性能与调试的几点个人体会
迭代器用多了,会形成一些直觉。这些直觉很难从文档里学到,都是踩坑踩出来的,我挑几个最有价值的分享。
第一,迭代器的开销主要在"每次推进的函数调用"上。 对于元素数量巨大的序列,这个开销会累积。如果你的场景对性能极度敏感,而且数据量确实很大,可以考虑"批量化"——让迭代器每次返回一批而不是一个,减少调用次数。但大多数业务场景下,这点开销完全可以忽略,不要过早优化。
第二,惰性链条的调试要用"分段求值"的思路。 一条长长的惰性流水线出问题时,不要盯着整条链看,而是在中间插入临时的终端操作,把链条切成几段,逐段验证。哪一段的输出不对,问题就在那一段。这个方法我用了无数次,屡试不爽。
第三,迭代器的单元测试要覆盖"空、单元素、多元素、提前中断"四种情况。 空和单元素覆盖边界,多元素覆盖正常流程,提前中断覆盖"没遍历完就退出"的场景(这个最容易出资源泄漏)。这四类用例写下来,迭代器的正确性基本就有保障了。
第四,不要为了用迭代器而用迭代器。 如果数据本来就全在内存里、长度也不大,直接用数组遍历更简单直接。迭代器的价值在于处理"大、流式、惰性、无限"这些场景,脱离这些场景硬套迭代器,只会增加代码复杂度。我见过有人把只有几个元素的配置列表也封装成迭代器,纯属自找麻烦。
第五,迭代器的接口设计要考虑"是否可重复遍历"。 如果你的类型实现的是 Iterable,那调用方可以放心多次遍历;如果实现的是 Iterator,那调用方必须知道它是一次性的。这个语义差别要在类型选择上体现出来,不要含糊。含糊的接口设计,最终都会变成调用方的 bug。
迭代器这个主题,入门容易精通难。表面上看就是"能一个个取元素",但背后牵扯到状态管理、惰性求值、资源生命周期、接口设计等一堆工程问题。我的建议是:先把 for-in 用熟,然后手写几个迭代器找找感觉,再尝试用迭代器重构一段你写过的循环逻辑。等你开始自然地用"数据源 + 中间操作 + 终端操作"的思维去组织代码时,迭代器就算真正入门了。