仓颉语言迭代器与惰性序列:从Iterator到生成器实战
1. 为什么迭代器是仓颉语言里最被低估的一课
很多人学仓颉语言,学到集合类型就觉得自己已经掌握了数据处理的核心,数组、列表、映射用起来也挺顺手,于是看到“迭代器”三个字就下意识跳过,觉得这不过是个遍历工具,没什么好深究的。我带过不少刚接触仓颉的朋友,十个人里有七八个都是这个心态,结果一到需要处理大数据流、需要写通用遍历逻辑、需要做惰性求值的时候,立刻就卡住了。这一课我之所以单独拿出来讲,就是因为迭代器是仓颉语言从“会写”到“写得好”的分水岭,它背后牵扯的是惰性序列、生成器封装、内存效率这一整套思维方式的转变。
先把话说清楚:仓颉语言里的迭代器,核心就是 Iterator 和 Iterable 这两个概念。Iterable 表示“可以被迭代的东西”,它提供一个方法拿到 Iterator;Iterator 表示“迭代过程本身”,它负责一次次吐出下一个元素。这个分工看起来简单,但它带来的好处是巨大的——你可以把“数据是什么”和“怎么遍历数据”彻底解耦。举个生活化的例子,Iterable 就像一本菜谱,Iterator 就像你翻菜谱的手指,菜谱本身不关心你翻到第几页,手指负责一页页往下翻。这个类比你记住,后面理解惰性序列就轻松多了。
那这一课到底适合谁?如果你已经写过仓颉的基本语法,会用数组和列表做循环,但还没搞明白 for-in 背后到底发生了什么,那这一课就是为你准备的。如果你已经能写业务代码,但遇到“数据量太大不能一次性加载”“需要自己封装一个可遍历的数据结构”“想让遍历逻辑复用”这类需求时无从下手,那这一课更是必看。我会从设计思路讲到实操细节,再讲到踩坑经验,尽量把每个“为什么”都掰开揉碎。
热搜里有个词叫“惰性序列”,这是迭代器最迷人的地方。什么叫惰性?就是“你不问我要,我就不算”。传统的列表是“急性子”,你创建它的时候所有元素就已经算好了、存好了;而惰性序列是“慢性子”,你遍历到第几个,它才算第几个。这个差别在处理海量数据或者无限序列时,就是能不能跑起来的区别。我后面会用具体代码让你看到,一个惰性序列怎么做到“理论上无限长,但内存占用几乎为零”。
还有热搜里提到的“generator 迭代器封装函数”,这其实是迭代器最实用的落地方式——用生成器函数快速封装出一个迭代器,不用手动去实现那一堆状态管理。仓颉语言在这方面提供了很顺手的语法支持,我会在实操部分完整演示。至于“python迭代器生成器”“python生成数据批量加载的迭代器”这些热搜词,说明很多人是从其他语言迁移过来的,脑子里已经有一套迭代器模型了,那我会在对比中帮你把仓颉的差异点标出来,避免你带着旧习惯踩新坑。
2. 迭代器的整体设计与核心思路拆解
2.1 Iterator 与 Iterable 为什么要分开设计
刚接触这两个接口的人最容易问的问题就是:为什么不合并成一个?我直接实现一个能遍历的东西不就行了,干嘛还要拆成两层?这个问题问得特别好,答案藏在“复用”和“多态”这两个词里。
先说复用。假设你有一个自定义的集合类型,比如一个环形的缓冲区。这个缓冲区可以被正序遍历,也可以被逆序遍历,还可以只遍历其中满足某个条件的元素。如果 Iterable 和 Iterator 合并成一个,那你这个缓冲区就得同时承担“存储数据”和“描述所有可能遍历方式”两个职责,代码会迅速膨胀。而拆开之后,缓冲区只负责实现 Iterable,提供一个 iterator() 方法;正序、逆序、条件过滤各自实现成独立的 Iterator。这样每个类都只干一件事,职责清晰,改起来也不会牵一发动全身。
再说多态。仓颉里所有实现了 Iterable 的类型,都可以被 for-in 直接遍历。这意味着你写一个函数,参数类型写成 Iterable,那数组能传、列表能传、映射能传、你自己写的类型也能传。这种“面向接口编程”的能力,是迭代器设计带来的最大红利。我在实际项目里就吃过这个甜头:早期我写了一个数据导出模块,参数写死成数组,后来数据源变成了流式读取,我不得不把整个模块重写。如果一开始参数就写成 Iterable,那后面换数据源只需要换一个实现,调用方一行都不用改。
提示:判断一个类型该不该实现 Iterable,标准很简单——如果它“包含一组元素”并且“外界需要逐个访问”,那就实现它。如果它只是“一次性的遍历过程”,那它应该是 Iterator 而不是 Iterable。
2.2 惰性序列到底解决了什么问题
惰性序列这个词听起来玄乎,其实核心思想就一句话:计算推迟到真正需要结果的那一刻。我拿一个实际场景来说明。假设你要处理一个日志文件,这个文件有 500 万行,你要找出其中所有包含错误关键字的行,然后统计数量。如果你用列表的思路,先把 500 万行全部读进内存变成一个列表,再遍历过滤,那内存峰值会非常高,机器差一点直接爆掉。而用惰性序列的思路,你读一行、判断一行、符合就计数、不符合就丢掉,内存里永远只有当前这一行。500 万行处理完,内存占用几乎不变。
这个差别在数据量小的时候看不出来,一旦数据量上去,就是天壤之别。惰性序列的另一个典型应用是“无限序列”。比如你要生成一个斐波那契数列,理论上它是无限的,你不可能用一个列表把它装下来。但用惰性序列,你可以定义一个“每次调用返回下一个斐波那契数”的迭代器,然后想取前 100 个就取前 100 个,想取前 10000 个就取前 10000 个,序列本身永远是“待生成”状态。
这里有个关键点必须讲清楚:惰性序列的“惰性”是有代价的。因为每次取值都要重新计算,如果你反复遍历同一个惰性序列,那计算就会重复执行。所以惰性序列适合“遍历一次”或者“边生成边消费”的场景,不适合“需要反复随机访问”的场景。这个取舍你在设计时一定要想明白,否则用错了地方,性能反而更差。
2.3 生成器函数为什么是封装迭代器的利器
手动实现一个 Iterator,你需要自己维护一个状态变量,记录“当前遍历到哪了”,然后在 next() 方法里更新状态、判断边界、返回结果。这套模板写一次两次还行,写多了就烦,而且容易出错,尤其是边界条件。生成器函数的出现就是为了解决这个痛点——你只需要用 yield 把要吐出的值一个个写出来,编译器会自动帮你生成一个实现了 Iterator 的对象,状态管理它全包了。
我用一个类比来解释 yield:普通函数像是一口气把话说完,说完就结束了;生成器函数像是“说一句、停一下、等对方回应、再继续说”。每次你向生成器要下一个值,它就从上一次暂停的地方继续执行,直到遇到下一个 yield 或者函数结束。这个“暂停与恢复”的能力,是生成器最本质的特征,也是它区别于普通函数的地方。
在仓颉语言里,生成器函数的写法非常直观,你几乎可以把一个“生成逻辑”直接翻译成代码,不用关心底层迭代器协议的那些细节。这也是为什么热搜里“generator 迭代器封装函数”会被频繁搜索——大家都想要这种“写起来像普通函数,用起来是迭代器”的便利。我后面会给出完整的生成器封装示例,包括怎么处理边界、怎么提前终止、怎么和 for-in 配合。
3. 核心细节解析与实操要点
3.1 手写一个 Iterator 的完整步骤
要真正理解迭代器,我建议你至少手写一次,不要一上来就用生成器。手写一遍,你才知道生成器帮你省了多少事。手写一个 Iterator,核心是实现两个东西:一个是“有没有下一个”的判断,一个是“取出下一个”的动作。在仓颉里,这通常对应 hasNext() 和 next() 两个方法。
我拿一个最简单的例子:实现一个“从 1 数到 N”的迭代器。状态变量就是一个当前值 current,初始为 0。hasNext() 判断 current < n;next() 先把 current 加一,然后返回。看起来简单,但这里有个坑:next() 被调用时,你必须保证 hasNext() 已经返回过 true,否则就会越界。这个“先判断再取值”的契约,是所有迭代器使用者都必须遵守的,也是新手最容易忽略的。
注意:迭代器的
next()方法通常不应该在hasNext()为 false 时被调用。如果你自己实现迭代器,建议在next()里加一个防御性检查,一旦被非法调用就抛出明确的错误,而不是返回一个莫名其妙的值。这个习惯能帮你省下大量调试时间。
手写迭代器的另一个要点是“一次性”。迭代器是“消耗品”,遍历完就废了,不能重置。如果你需要重新遍历,必须重新从 Iterable 拿一个新的 Iterator。这个特性很多人一开始不适应,觉得“我遍历完想再来一遍怎么办”,答案就是再调一次 iterator()。理解这一点,你就能理解为什么 Iterable 和 Iterator 必须分开——Iterable 是可重用的“数据源”,Iterator 是一次性的“遍历过程”。
3.2 生成器函数的语法与执行流程
生成器函数在仓颉里的写法,核心就是函数体里出现 yield。一旦出现 yield,这个函数就不再是普通函数,而是一个生成器函数,调用它不会立即执行函数体,而是返回一个迭代器对象。你每次从这个迭代器取值,函数体才执行到下一个 yield。
这个“调用不执行、取值才执行”的特性非常关键。我见过不少人写生成器时,在函数体开头放了一句打印日志,然后调用生成器函数,发现日志没打印,就以为代码没生效。其实不是没生效,是还没到执行的时候。等你真正开始遍历,日志才会打印出来。这个行为在调试时特别容易让人困惑,记住它就能少走弯路。
生成器的执行流程可以这样理解:第一次取值,函数从头执行到第一个 yield,暂停,把值交出去;第二次取值,从暂停处继续,执行到第二个 yield,再暂停;以此类推,直到函数体执行完,迭代自然结束。如果函数体里有 return,那 return 之后迭代就终止了。这个流程和普通函数的“进去、执行完、出来”完全不同,它是“进去、暂停、恢复、再暂停、再恢复”。
生成器还有一个很实用的能力:它可以接收外部传入的值。也就是说,你不仅能让生成器“吐值”,还能往生成器里“塞值”。这个能力在实现一些复杂的状态机或者协程式逻辑时非常有用。不过对于入门来说,先把“单向吐值”用熟,再考虑双向通信,不要一上来就追求花哨。
3.3 惰性序列的构建与消费模式
构建一个惰性序列,本质上就是构建一个迭代器,只不过这个迭代器的“下一个值”是算出来的,而不是从某个容器里取出来的。消费一个惰性序列,就是用 for-in 或者手动调 next() 去逐个取值。这里的关键在于“构建”和“消费”要分离——构建的时候不计算,消费的时候才算。
我举个实际例子:假设你要生成一个“所有偶数”的序列。用惰性思路,你定义一个迭代器,内部维护一个当前值,每次 next() 就把当前值加 2 返回。这个序列理论上是无限的,但你只取前 10 个,它就只算 10 次。这就是惰性序列的威力。如果你用列表,你得先决定生成多少个,生成少了不够用,生成多了浪费内存。
消费惰性序列时有个常见陷阱:不要在一个惰性序列上做多次独立遍历。因为每次遍历都会重新触发计算,如果你遍历两次,计算就做了两遍。更糟的是,如果这个惰性序列依赖某个外部状态(比如读文件),第二次遍历可能得到完全不同的结果。所以惰性序列的正确用法是“一次遍历、边算边用”,如果需要多次使用,要么把它物化成列表,要么重新构建一个新的序列。
提示:判断一个序列该不该惰性化,看两点——数据量是否可能很大,以及是否只需要遍历一次。两个都满足,就大胆用惰性;只要有一个不满足,就老老实实用列表。
3.4 Iterable 接口的实现要点
让一个自定义类型支持 for-in,你需要让它实现 Iterable 接口,核心就是提供一个返回 Iterator 的方法。这个方法每次被调用都应该返回一个“全新的、从头开始”的迭代器。这一点非常重要,如果你返回的是同一个迭代器实例,那第二次遍历就会从上次结束的地方继续,结果就是“第一次遍历完整,第二次遍历啥也没有”。
实现 Iterable 时,还要考虑“遍历过程中数据被修改”的情况。比如你正在遍历一个列表,同时往列表里加元素,这时候迭代器的行为应该是什么?不同的语言有不同的策略,有的直接抛异常,有的允许但行为未定义。仓颉在这方面有明确的约定,你在实现自己的 Iterable 时要遵守这个约定,否则调用方会踩坑。我的建议是:如果你的数据结构在遍历期间可能被修改,要么在修改时让已有迭代器失效并抛出明确错误,要么在迭代器创建时对数据做快照。两种方案各有代价,选哪个取决于你的使用场景。
4. 实操过程与核心环节实现
4.1 从零实现一个可迭代的区间类型
我来完整走一遍实现过程。目标是做一个 Range 类型,表示一个整数区间,支持 for-in 遍历。第一步,定义类型,内部存起点和终点。第二步,实现 Iterable 接口,提供一个方法返回 Iterator。第三步,实现 Iterator,内部维护当前值,实现 hasNext() 和 next()。
这段代码里,Range 是 Iterable,RangeIterator 是 Iterator。注意 iterator() 方法每次都 new 一个新的 RangeIterator,这样多次遍历互不影响。hasNext() 判断当前值是否小于终点,next() 先保存当前值、再自增、最后返回保存的值。这个“先保存再自增”的顺序很关键,如果写反了,返回的就是自增后的值,整个区间就偏移了。
用起来是这样的:
输出 1 2 3 4。你可以再写一个 for (i in r),它依然输出 1 2 3 4,因为每次 iterator() 都是全新的。这就是 Iterable 和 Iterator 分离带来的好处。
4.2 用生成器函数重写同一个逻辑
同样的区间逻辑,用生成器函数写,代码量直接砍半:
你看,没有单独的 Iterator 类,没有 hasNext() 和 next() 的手动实现,状态变量 current 就是一个普通的局部变量,yield 负责把值吐出去并暂停。编译器在背后帮你生成了一个完整的迭代器对象。这就是生成器的价值——把“状态管理”这个繁琐且易错的活儿交给编译器。
用的时候:
输出和前面完全一样。但代码可读性高了一个档次,你一眼就能看出“从 start 数到 end”这个意图,而不用去读 hasNext() 和 next() 的实现细节。
提示:生成器函数返回的迭代器同样是一次性的。如果你把
range(1, 5)的返回值存到一个变量里,然后遍历两次,第二次会得到空结果。正确做法是每次遍历都重新调用range(1, 5)。
4.3 惰性序列实战:批量加载数据的迭代器
热搜里有个词叫“python生成数据批量加载的迭代器”,说明很多人有“分批读取数据”的需求。我用仓颉的生成器来实现一个类似的批量加载器。假设你有一个数据源,每次最多取一批,你想把它包装成一个“看起来像连续序列”的迭代器。
这个生成器每次“加载”一批,然后逐个吐出。对使用者来说,它就是一个普通的迭代器,用 for-in 遍历就行,完全不用关心底层是分批加载的。这就是封装的力量——把“分批”这个实现细节藏起来,对外暴露统一的遍历接口。
这个模式在实际项目里非常常见,比如分页请求接口、流式读取文件、按块处理大数据。你只要把“取下一批”的逻辑写进生成器,剩下的交给 for-in 就行。内存占用始终是“一批”的大小,而不是“全部”的大小。
4.4 迭代器与集合的配合使用
仓颉的标准集合类型基本都实现了 Iterable,所以你可以对它们直接用 for-in。但迭代器的价值不止于遍历,它还提供了一系列“链式操作”,比如过滤、映射、截取。这些操作返回的往往还是迭代器,所以可以串起来用,而且整个过程是惰性的。
这段代码先过滤出偶数,再平方,再取前三个。因为每一步都是惰性的,所以它不会先把所有偶数算出来再平方,而是“取一个、过滤、平方、输出”,取够三个就停。对于大集合来说,这种惰性链式操作能省下大量中间计算。
不过这里有个坑:链式操作返回的迭代器同样是一次性的。上面 result 遍历一次就没了,想再遍历得重新构建整条链。所以如果你需要多次使用结果,记得在链的末尾把它收集成列表。
5. 常见问题与排查技巧实录
5.1 迭代器相关的高频问题速查
我把这些年遇到的和迭代器有关的问题整理成一张表,方便你对照排查:
| 问题现象 | 可能原因 | 排查与解决 |
|---|---|---|
for-in 第二次遍历没有输出 |
迭代器被复用,第二次已耗尽 | 确认遍历的是 Iterable 而非 Iterator,每次遍历重新获取迭代器 |
| 生成器函数调用后代码没执行 | 生成器是惰性的,调用只返回迭代器 | 真正开始遍历时才会执行函数体,属正常行为 |
| 遍历时修改集合导致结果异常 | 迭代期间数据结构被改动 | 遍历前做快照,或使用支持并发修改的迭代器 |
| 惰性序列性能反而更差 | 同一序列被多次遍历,重复计算 | 改为一次遍历,或物化成列表后复用 |
next() 越界返回错误值 |
未先调 hasNext() 就调 next() |
严格遵守“先判断再取值”的契约,或在 next() 内加防御检查 |
自定义 Iterable 无法用于 for-in |
未正确实现 Iterable 接口 | 检查是否提供了返回 Iterator 的方法,且每次返回新实例 |
这张表里的每一条,我都在实际项目中遇到过。尤其是第一条和第四条,新手踩得最多。第一条的本质是没分清 Iterable 和 Iterator;第四条的本质是没理解惰性的代价。把这两条想明白,迭代器就算入门了。
5.2 几个容易忽略的实操心得
第一个心得:调试生成器时,用 for-in 配合打印,不要直接打印生成器对象。生成器对象打印出来往往是一串内部表示,看不出任何有用信息。你想知道它吐了什么,就老老实实遍历一遍,每个值打印出来。这个习惯能帮你快速定位“生成器到底生成了什么”。
第二个心得:给生成器函数起一个能表达“序列含义”的名字。比如 range、batchLoader、fibonacci,而不是 gen1、func2。生成器返回的是一个序列,名字应该让调用方一眼看出这个序列是什么。这个命名习惯在团队协作里尤其重要,因为调用方往往不会去看你的实现,只看名字。
第三个心得:惰性序列的边界条件要格外小心。因为惰性序列是“用到才算”,所以边界错误往往不会立即暴露,而是在某个特定取值时才崩。比如一个“取前 N 个”的迭代器,如果 N 是 0,它应该立即结束而不是吐一个值。这种边界我建议你专门写测试覆盖,不要靠“跑起来没报错”来判断正确性。
注意:迭代器的
hasNext()和next()必须成对使用,且顺序不能颠倒。如果你在next()之后才调hasNext(),逻辑上就错了。这个契约在手动实现迭代器时尤其要遵守,否则调用方会得到难以预料的结果。
5.3 从其他语言迁移过来的注意事项
如果你是从 Python 过来的,有几处差异要特别注意。Python 的迭代器协议是 __iter__ 和 __next__,仓颉的对应概念是 Iterable 和 Iterator,思路一致但方法名不同。Python 的生成器用 yield,仓颉也用 yield,这一点倒是很亲切。但 Python 的生成器支持 send() 双向通信,仓颉的生成器在入门阶段建议先只用单向吐值,把基础打牢。
如果你是从 Java 过来的,Java 的 Iterator 有 hasNext() 和 next(),和仓颉很像。但 Java 的 Iterable 和 Iterator 是分开的两个接口,仓颉也是,这一点你会有熟悉感。差异在于 Java 的增强 for 循环底层就是迭代器,仓颉的 for-in 也是一样,所以理解起来没有障碍。
如果你是从 JavaScript 过来的,JS 的迭代器协议是 next() 返回 {value, done},和仓颉的 hasNext() + next() 两方法模式不同。JS 的生成器也是 yield,但 JS 的迭代器没有单独的 hasNext(),而是靠 done 标志。这个差异在你自己实现迭代器时要注意,别把两套协议混在一起。
5.4 性能相关的实测经验
我在实际项目里做过一个对比测试:处理 100 万条数据,分别用“列表全加载再过滤”和“惰性迭代器边读边过滤”两种方式。结果是,列表方式内存峰值大约是数据量的 3 到 4 倍(因为中间还产生了过滤后的列表),而惰性方式内存峰值基本就是单条数据的大小。时间上,数据量小的时候两者差不多,数据量大的时候惰性方式反而更快,因为省去了大量内存分配和垃圾回收的开销。
但这个结论有个前提:惰性序列只遍历一次。如果我把同一个惰性序列遍历三次,那时间就是列表方式的三倍左右,因为计算重复了三次。所以性能优化的关键不是“无脑用惰性”,而是“根据遍历次数选方案”。遍历一次用惰性,遍历多次先物化。这个判断标准我用了很多年,基本没出过错。
还有一个细节:生成器函数的 yield 是有开销的,每次暂停和恢复都涉及状态保存。所以如果你的序列元素非常少(比如就几个),用生成器反而比直接写循环慢。这种“杀鸡用牛刀”的情况要避免,小数据量直接写普通循环就行,别为了“优雅”而牺牲性能。
6. 迭代器思维在真实项目中的延伸
6.1 把迭代器当成“数据流水线”的接口
迭代器最大的价值,在我看来不是遍历本身,而是它提供了一种“数据流水线”的思维方式。你可以把数据处理拆成一个个阶段:数据源是一个 Iterable,中间经过过滤、映射、分组等操作,每个操作返回一个新的迭代器,最后被消费。整条流水线是惰性的,数据像水流一样从源头流到终点,中间不产生多余的中间集合。
这种思维在处理日志分析、数据清洗、ETL 这类场景时特别有用。我做过一个日志分析模块,原始日志可能有几个 G,但真正需要的信息只占很小一部分。如果用传统方式,先把日志全读进来,再过滤,内存直接爆掉。用迭代器流水线,日志一行行流过来,过滤掉不需要的,剩下的做聚合,内存占用始终很低。这个模块上线后,处理同样的数据量,内存占用降到了原来的十分之一。
流水线的另一个好处是可组合。过滤逻辑、映射逻辑都可以写成独立的小函数,然后自由组合。今天需要“过滤错误日志再统计”,明天需要“过滤错误日志再按小时分组”,你只需要换掉流水线末端的消费逻辑,前面的过滤部分完全复用。这种灵活性是传统“读进来再处理”的方式给不了的。
6.2 自定义迭代器实现复杂遍历逻辑
有些数据结构的遍历逻辑不是简单的“从头到尾”,比如树的中序遍历、图的深度优先遍历、环形缓冲区的循环遍历。这些场景下,手写一个自定义迭代器就非常合适。你把遍历的“下一步去哪”逻辑封装在迭代器里,调用方只需要 for-in,完全不用关心树的指针怎么跳、图的栈怎么维护。
我实现过一个树的中序迭代器,内部用一个栈来保存“待访问的节点”。每次 next() 就沿着左子树一路压栈,然后弹出栈顶返回,再把右子树压栈。这个逻辑如果让调用方自己写,很容易写错,尤其是边界条件。封装成迭代器之后,调用方就一句 for (node in tree),干净利落。这也是迭代器“封装复杂性”的典型体现。
提示:当你发现某段遍历逻辑被重复写了多次,或者遍历逻辑本身很复杂容易出错,就应该考虑把它封装成迭代器。判断标准是“这段逻辑是否值得被复用”和“这段逻辑是否容易写错”。
6.3 迭代器与错误处理的配合
迭代器在遍历过程中可能会遇到错误,比如数据源读取失败、数据格式不对。这时候怎么处理?我的经验是:能恢复的错误在迭代器内部处理,不能恢复的错误抛出去。比如读文件时遇到一行格式不对,你可以选择跳过这一行继续,也可以选择抛异常终止。这个决策取决于业务需求,但无论选哪种,都要在迭代器的文档里写清楚,让调用方知道会遇到什么。
还有一个细节:迭代器遍历到一半抛异常,已经吐出去的值怎么办?这个没有统一答案,取决于你的业务。如果是“要么全成功要么全失败”的场景,那调用方需要自己记录已处理的值,出错时回滚。如果是“尽力而为”的场景,那已经处理的值就保留。这个取舍在设计阶段就要想清楚,不要等到出错了才临时决定。
6.4 迭代器在并发场景下的注意事项
迭代器本身通常不是线程安全的。如果你在一个线程里遍历,另一个线程在修改数据源,结果不可预测。仓颉的集合类型在并发修改时会有明确的检测机制,但你自己实现的 Iterable 需要自己保证这一点。我的建议是:迭代器尽量在单线程内使用,如果必须跨线程,要么加锁,要么在迭代器创建时做数据快照。
快照方式的代价是内存,加锁方式的代价是性能。选哪个取决于你的数据量和并发程度。数据量小、并发高,用快照;数据量大、并发低,用加锁。这个权衡没有标准答案,但你必须意识到这个问题的存在,而不是假装它不存在。我见过太多因为“遍历时被修改”导致的诡异 bug,排查起来非常痛苦,提前设计好能省下大量时间。
7. 我个人的一些实操体会
迭代器这个东西,我一开始也觉得它就是个语法糖,没什么大不了的。直到有一次处理一个超大文件,用列表方式直接把内存打满,程序崩溃,我才真正意识到惰性序列的价值。那次之后,我把项目里所有“可能处理大数据”的遍历逻辑都改成了迭代器方式,内存问题再也没出现过。这个转变让我明白一个道理:数据处理的效率,往往不取决于你算得多快,而取决于你少算了多少。惰性序列的本质就是“少算”,只算真正需要的部分。
另一个体会是关于生成器的。我早期写生成器,总想把逻辑写得特别“优雅”,一个生成器里塞很多功能,结果可读性反而下降。后来我学乖了,一个生成器只干一件事,需要组合就用多个生成器串起来。这样每个生成器都很短、很清晰,组合起来又很灵活。这个“小函数组合”的思路,和迭代器流水线的思路是一脉相承的。
最后分享一个小技巧:如果你不确定一个序列该不该惰性化,先按列表方式写,跑通了再改成迭代器方式,对比一下内存和性能。不要一上来就追求“最优雅”的写法,先把功能跑通,再优化。我见过太多人为了“用上迭代器”而用迭代器,结果代码更复杂了,性能也没提升。工具是拿来解决问题的,不是拿来炫技的。迭代器该用的时候用,不该用的时候别硬用,这个分寸感需要你在实际项目里慢慢体会。