Dart 之可迭代对象与生成器

作者:好的佩奇日期:2026/11/17

前言

买菜时,我们可以先写好一张清单,再一项一项检查;也可以边走边看,找到需要的东西就记下来。两种方式都能得到一张清单,但做事的时机不同:前者先准备结果,后者需要某一项时才处理某一项。

Dart 里的 Iterable 就像“可以逐项查看的清单”。它不一定是一张已经准备好的 List,也可能是一套等到有人读取时才计算的规则。sync* 生成器则能把这套规则写成“每次交出一个值”的函数。

理解这一点后,where、map、take 为什么可以连在一起,为什么只取第一个结果时不用处理全部数据,以及 async* 为什么返回的是 Stream,就都有了清楚的原因。

一、Iterable:可以逐项读取的一组值

1.1 先看定义

Iterable 表示一组可以按顺序逐项读取的值。 这里的“按顺序”是读取方式,不是说它一定支持下标,也不是说它一定能修改。 Iterable

List 是最常见的 Iterable:

1void main() {
2  final names = <String>['林', '周', '吴'];
3
4  Iterable<String> readable = names;
5
6  print(readable.first); // 林
7  print(readable.length); // 3
8  print(readable.join('、')); // 林、周、吴
9}
10

names 的实际类型是 List<String>,但放进 Iterable<String> 变量后,代码只依赖“能够逐项读取”这部分能力。Iterable 没有要求所有实现都提供 []、add 或 remove,所以不能因为某个对象能遍历,就假定它一定是一张可修改的列表。

可以把几种类型先这样区分:

类型主要表示什么常见能力
Iterable<T>可以逐项读取的值for-in、first、where、map
List<T>有顺序、可按位置访问的一组值[]、add、remove
Set<T>不重复的一组值查找和逐项读取,不能按下标取值
Stream<T>随时间到来的异步值异步监听、暂停、取消

把类型写成 Iterable<T>,是在表达“调用者只需要逐项读取”。 如果调用者确实需要按下标修改,才应该让它看到 List<T> 或更具体的接口。

1.2 for-in 是怎样读取的

for-in 不是一次把所有值变成另一张列表,而是通过迭代器逐项取得:

1void main() {
2  final names = <String>['林', '周', '吴'];
3
4  for (final name in names) {
5    print('读取:$name');
6  }
7}
8

可以把它理解成三个动作:

  1. 取得这组值的迭代器;
  2. 询问还有没有下一项;
  3. 有就取出这一项,执行循环体,然后继续询问。

大多数时候不需要手写迭代器。这里写出底层概念,是为了说明 Iterable 的重点是“怎样逐项提供值”,而不是“内部一定存着一张数组”。

二、惰性 Iterable:调用方法不等于马上算完

2.1 map 先保存规则

惰性 Iterable 会先保存处理规则,等到真正读取时才执行规则。 where、map、take、skip 等常用操作通常会返回惰性 Iterable。

1void main() {
2  final numbers = <int>[1, 2, 3];
3
4  final doubled = numbers.map((number) {
5    print('计算 $number');
6    return number * 2;
7  });
8
9  print('已经创建 doubled');
10  print(doubled.first);
11}
12

输出顺序是:

1已经创建 doubled
2计算 1
32
4

创建 doubled 时,没有打印“计算 1”。直到读取 doubled.first,Dart 才从 numbers 取第一项,执行转换,并在得到第一个结果后停止。

这和下面的写法不同:

1void main() {
2  final numbers = <int>[1, 2, 3];
3
4  final doubled = numbers.map((number) {
5    print('计算 $number');
6    return number * 2;
7  }).toList();
8
9  print('已经创建 doubled');
10  print(doubled.first);
11}
12

这里 toList() 必须创建一张完整的新列表,所以会先计算 1、2、3,然后才打印“已经创建 doubled”。

map 不负责把结果装进新列表;它负责描述“每个输入怎样变成一个输出”。 需要完整结果时再调用 toList(),可以明确表达这个需求。

2.2 惰性不等于缓存

惰性 Iterable 通常不会自动记住上一次遍历的结果。每次重新遍历,都可能重新执行处理函数:

1void main() {
2  final numbers = <int>[1, 2, 3];
3
4  final doubled = numbers.map((number) {
5    print('计算 $number');
6    return number * 2;
7  });
8
9  print(doubled.first);
10  print(doubled.last);
11}
12

第一次读取 first 至少需要计算到 1。第二次读取 last 又要从头找到最后一项,因此可能再次计算 1、2、3。不要把发送请求、写文件或修改外部变量等有副作用的操作随便放进惰性转换里,再假定它只会执行一次。

如果结果需要重复使用,可以主动物化:

1void main() {
2  final numbers = <int>[1, 2, 3];
3  final doubled = numbers.map((number) => number * 2).toList();
4
5  print(doubled); // [2, 4, 6]
6}
7

此时转换在 toList() 处完成,后续读取 doubled 不会再次调用 map 的转换函数;代价是保存完整结果,需要相应内存。

2.3 输入改变时也要看实现

惰性操作通常会在遍历时读取来源。因此,如果来源是一张后来还能修改的列表,重新遍历时可能看到新的内容:

1void main() {
2  final numbers = <int>[1, 2];
3  final doubled = numbers.map((number) => number * 2);
4
5  numbers.add(3);
6
7  print(doubled.toList()); // [2, 4, 6]
8}
9

这里没有在创建 doubled 时复制 numbers。需要固定快照时,应该在合适的时机调用 toList();需要跟随来源变化时,才保留惰性关系。关键是明确数据应该“固定下来”还是“读取时再看”。

三、把处理步骤连起来:where、map、take 和 skip

3.1 每一步分别做什么

处理一批数据时,常见的四个操作可以这样记:

  • where:留下满足条件的项;
  • map:把每一项转换成另一种结果;
  • take:最多取前几项;
  • skip:跳过前几项,再读取后面的内容。
1void main() {
2  final prices = <int>[8, 15, 23, 31, 42];
3
4  final labels = prices
5      .where((price) => price >= 20)
6      .map((price) => '价格:$price 元')
7      .take(2);
8
9  print(labels.toList()); // [价格:23 元, 价格:31 元]
10}
11

这里的顺序不是装饰:

  1. 先检查价格是否至少为 20;
  2. 对留下的价格生成文字;
  3. 只取前两条;
  4. toList() 把最终结果保存成列表。

如果把 take(2) 放在 where 前面,就会先只看 8 和 15,之后没有符合条件的项,结果会变成空列表。链式调用中,前一步输出的是什么,决定后一步能看到什么。

3.2 为什么只处理到 31

这条链是惰性的。为了得到前两条符合条件的结果,程序会读取 8、15、23、31;得到第二条后,take(2) 就结束了,不需要再读取 42。

可以把它看成一条传送带:

18 ──> where:丢弃 ──> 不再进入后面
215 ─> where:丢弃 ──> 不再进入后面
323 ─> where:保留 ──> map ──> take:第 1 条
431 ─> where:保留 ──> map ──> take:第 2 条 ──> 停止
542 ─> 尚未读取
6

这不是说所有操作都能提前停止。last 需要知道最后一项,toList() 需要完整结果,length 通常也需要遍历全部来源。是否能少读数据,取决于链中最终的操作和每个步骤的语义。

3.3 skip 只改变开始位置

1void main() {
2  final names = <String>['林', '周', '吴', '郑'];
3
4  final later = names.skip(2);
5
6  print(later.toList()); // [吴, 郑]
7}
8

skip(2) 不会把前两项删除,也不会修改 names。它只是在遍历这个结果时,先跳过两个值。

类似地,take(2) 也不会修改来源。Iterable 的链式方法通常返回新的读取视图;如果需要改变 List,本身应使用 List 的修改方法,不能把 where 或 skip 当成删除操作。

四、哪些操作会真正遍历来源

4.1 读取一个值和读取全部值

惰性只是延后计算,不是永远不计算。下面这些操作会触发读取:

  • first、single 等需要找到特定结果的操作;
  • last、length 等通常要继续看到后面的内容;
  • toList()、toSet() 等需要生成完整集合的操作;
  • for-in、forEach() 等逐项执行的操作;
  • join()、reduce() 等需要综合多个值的操作。
1void main() {
2  final values = <int>[4, 7, 9];
3
4  final even = values.where((value) {
5    print('检查 $value');
6    return value.isEven;
7  });
8
9  print(even.first);
10}
11

输出只检查 4,就得到第一个偶数。若把最后一行改成 print(even.toList());,三个值都会被检查。

single 还会继续检查,确认整个来源只有一个符合条件的值;不能看到第一项就立即结束。遇到空结果或多个结果时,它会抛出异常。选择操作时,要把“我要第一个”“我要全部”“我要确认只有一个”说清楚。

4.2 多次遍历的边界

同一个惰性结果可以被遍历多次,但每次遍历都可能重新读取来源:

1void main() {
2  final source = <int>[1, 2, 3];
3
4  final result = source.map((value) {
5    print('处理 $value');
6    return value + 10;
7  });
8
9  print(result.toList());
10  print(result.toList());
11}
12

两次 toList() 都会触发处理。若转换很耗时,或来源会变化,这一点尤其重要。想要一次计算、多次读取,就在第一次需要时保存 toList() 的结果。

五、用 sync* 写一个同步生成器

5.1 先理解生成器在做什么

生成器函数不是一次性返回一张完整集合,而是按规则逐个交出值。 同步生成器使用 sync*,返回类型通常是 Iterable<T>。 生成器函数

1Iterable<int> countdown(int start) sync* {
2  for (var value = start; value >= 1; value--) {
3    yield value;
4  }
5}
6
7void main() {
8  final values = countdown(3);
9
10  print(values.first); // 3
11  print(values.toList()); // [3, 2, 1]
12}
13

yield 可以理解成“先把当前值交出去,调用者需要下一项时再继续”。调用 countdown(3) 得到的是一个 Iterable<int>,函数体不会像普通函数那样立刻执行完整流程。

第一次读取 first 时,函数交出 3 就停下。之后再次遍历 values,生成器会重新开始一轮生成,所以又能得到 3、2、1。生成器结果同样要注意是否重复计算。

5.2 生成器必须能结束

生成器中的循环必须有结束条件,或者调用者必须通过 take 等操作只读取有限项:

1Iterable<int> positiveNumbers() sync* {
2  var value = 1;
3  while (true) {
4    yield value++;
5  }
6}
7
8void main() {
9  final firstFive = positiveNumbers().take(5).toList();
10  print(firstFive); // [1, 2, 3, 4, 5]
11}
12

如果直接对 positiveNumbers() 调用 toList(),它会一直等待更多值,无法得到完整列表。无限生成器不是错误,但必须搭配明确的停止条件,例如 take(5)。

写 sync* 时要同时回答:第一项是什么?下一项怎样产生?什么时候结束?

5.3 生成器可以表达更复杂的规则

集合 for 适合短小的生成逻辑;当规则需要多个判断、递归或复用其他来源时,生成器更容易读懂:

1Iterable<String> availableSeats(
2  int rowCount,
3  int seatsPerRow,
4) sync* {
5  for (var row = 1; row <= rowCount; row++) {
6    for (var seat = 1; seat <= seatsPerRow; seat++) {
7      yield '$row-$seat';
8    }
9  }
10}
11
12void main() {
13  print(availableSeats(2, 3).toList());
14  // [1-1, 1-2, 1-3, 2-1, 2-2, 2-3]
15}
16

这里没有先创建所有座位的中间列表。每次读取时,生成器计算一个座位并交出它;调用者决定读取一个、几个,还是全部。

六、yield*:把另一组值接到当前生成器后面

6.1 转发一组 Iterable

yield* 会逐项转发另一个 Iterable 的内容。 它不是把整张列表作为一个值交出去:

1Iterable<String> languages() sync* {
2  yield 'Dart';
3  yield* <String>['Flutter', 'Android'];
4  yield 'C#';
5}
6
7void main() {
8  print(languages().toList()); // [Dart, Flutter, Android, C#]
9}
10

如果写成 yield <String>['Flutter', 'Android'];,生成器的元素类型就会变成 Object 或 Object? 一类,结果中会出现一张列表作为一项;yield* 表达的是“把里面每一项依次转发”。

yield* 也会保留来源的读取时机,不会为了转发而自动把来源先复制成另一张列表。

6.2 递归生成器需要结束条件

递归生成器适合表达“先给当前值,再生成更小问题”的规则:

1Iterable<int> downFrom(int value) sync* {
2  if (value < 1) {
3    return;
4  }
5
6  yield value;
7  yield* downFrom(value - 1);
8}
9
10void main() {
11  print(downFrom(4).toList()); // [4, 3, 2, 1]
12}
13

value 小于 1 时直接结束;否则先交出当前值,再把 value - 1 的结果接在后面。如果忘记结束条件,递归就不会停止,读取结果时会抛出错误或持续消耗资源。

yield* 右侧必须提供与当前生成器元素类型相容的 Iterable。它适合“把另一组同类值接进来”,不适合把一张列表当作单个业务对象交出去。

七、同步生成器和异步生成器不是一回事

7.1 sync* 返回 Iterable

同步生成器的每个值,是调用者在当前遍历中请求时交出的:

1Iterable<int> syncValues() sync* {
2  yield 1;
3  yield 2;
4}
5
6void main() {
7  for (final value in syncValues()) {
8    print(value);
9  }
10}
11

它适合已经在内存中,或可以同步计算得到的值。for-in 可以读取它。

7.2 async* 返回 Stream

异步生成器使用 async*,返回 Stream<T>。它可以在 yield 之间等待异步操作:Dart 中的并发模型

1Stream<int> asyncValues() async* {
2  await Future<void>.delayed(const Duration(milliseconds: 10));
3  yield 1;
4  await Future<void>.delayed(const Duration(milliseconds: 10));
5  yield 2;
6}
7
8Future<void> main() async {
9  await for (final value in asyncValues()) {
10    print(value);
11  }
12}
13

这里的值不是通过普通 for-in 读取,而是通过 await for 监听。Stream 还涉及事件到达时间、暂停、取消和错误传播等异步行为。

可以用下面的表格记住边界:

写法返回类型值什么时候产生读取方式适合场景
普通函数返回 List<T>List<T>函数返回前通常已构建结果下标、for-in需要保存完整结果
普通函数返回 Iterable<T>Iterable<T>由实现决定for-in 等提供逐项读取接口
sync*Iterable<T>遍历请求某项时for-in、first 等同步规则生成
async*Stream<T>异步事件准备好时await for、监听定时器、文件、网络等

async* 不是“更慢的 sync*”,Stream 也不是“会等待的 Iterable”。两者的读取协议不同:一个在同步遍历中交值,一个在异步事件流中发值。

7.3 选择哪一种

可以先问三个问题:

  1. 值是否已经能在当前调用中同步得到?
  2. 调用者是否只需要逐项读取,还是要等待未来事件?
  3. 是否需要保存完整结果,还是希望读到需要的数量就停止?

如果答案是“同步、逐项读取、可以按需停止”,优先考虑 Iterable 或 sync*。如果值要等待异步操作、可能随时间陆续到来,考虑 Stream 或 async*。如果后续要按下标重复访问,或者需要固定快照,调用 toList() 得到列表。

八、总结

Iterable 描述的是逐项读取能力。List、Set 和许多处理方法都可以提供 Iterable,但 Iterable 本身不承诺下标访问和修改。

where、map、take、skip 通常是惰性的:创建处理链时先保存规则,真正遍历时才计算。first 可能只读到第一个结果,toList() 则会要求完整遍历;多次遍历可能重复计算,想缓存就主动物化。

sync* 用 yield 逐项生成同步值,yield* 把另一组 Iterable 的内容依次转发。生成器要有明确的结束条件,或者由调用者用 take 限制读取范围。

async* 返回 Stream,通过 await for 或监听异步事件。选择 Iterable、列表、生成器还是 Stream,取决于值的产生时间、调用者的读取方式,以及是否需要保存完整结果。

九、测试题

  1. List<String> 为什么可以赋给 Iterable<String>?赋值以后,为什么不能只凭 Iterable 类型调用 add 和下标写入?
  2. 创建 numbers.map(...) 时,转换函数是否已经执行?什么操作会让它开始执行?
  3. 为什么对同一个惰性 Iterable 调用两次 toList(),转换函数可能执行两次?怎样得到一次计算、多次读取的结果?
  4. where(...).map(...).take(2) 中,如果把 take(2) 放到 where 前面,结果为什么可能不同?
  5. 对 values.where(...) 使用 first 和 toList(),它们读取来源的范围有什么区别?
  6. sync* 函数中的 yield 与普通函数中的 return 有什么不同?调用生成器函数时,函数体是否一定立即执行完?
  7. 无限生成器为什么可以定义?直接调用 toList() 会发生什么?怎样安全地读取前五项?
  8. yield <String>['Flutter', 'Android'] 与 yield* <String>['Flutter', 'Android'] 的结果结构有什么区别?
  9. sync* 和 async* 分别返回什么类型?它们对应的遍历方式为什么不同?
  10. 一个数据源需要等待网络响应并陆续产生结果,另一个数据源是内存中的整数计算。分别应该考虑 async*/Stream 和 sync*/Iterable 的哪一种?为什么?

参考文档


《Dart 之可迭代对象与生成器》 是转载文章,点击查看原文。


相关推荐


FSNotes:macOS 和 iOS 上的开源笔记管理器
kk_net88992026/11/8

文章目录 FSNotes:macOS 和 iOS 上的开源笔记管理器核心特点:Markdown 优先,原生体验iCloud 同步,跨设备使用一些有意思的细节谁适合用这个最后 FSNotes:macOS 和 iOS 上的开源笔记管理器 最近翻 GitHub 发现一个老牌项目 FSNotes,Star 数 7,413,作者已经维护了好几年。这工具解决的问题特别实在,给苹果生态用户提供一个原生、轻量、Markdown 优先的笔记应用。 我自己用 macOS 多年,一直找顺手的笔记软件。


AA我来算小程序实践:把付款人、承担人和结算状态分开建模
ngaiwe2026/10/31

多人AA记账的难点,往往不是求和,而是把不同业务事实放进了同一个字段。本文结合AA我来算微信小程序,拆解付款人、承担人、消费状态和结清标记之间的边界。 我是AA我来算的运营,本文根据项目已有业务能力整理,是产品方的实践介绍。下面的数据与TypeScript结构是用于说明业务的示例,不是生产源码,也不讨论资金清算或支付通道实现。 1. 付款人不一定承担这笔消费 四个人出游,A订酒店,B付晚餐,C替B和D付一段打车费,C本人没有坐这段车。 如果账单只有一个payer字段,再默认所有账本成员分摊,就会


用了两年多 GPT,我最近开始换模型了,还折腾了个求职避坑 Agent
程序员海军2026/10/23

大家好,我是程序员海军,OPC|AI 爱好者|独立开发者。 GPT 算是我这两年多用得最勤的 AI 工具了。 从一开始拿它查资料、写代码,到后来做需求分析、开发 AI 应用,甚至平时一些琐碎的事情,我基本都是先打开 GPT。说它是我的主战场,一点也不夸张。 但最近几个月,用起来是真的有点烦。 有时候需求已经讲得很清楚了,它还是理解偏了;复杂一点的任务,来回沟通几轮也收不了尾。以前觉得它挺省心,现在反倒需要自己一直盯着、纠正。偶尔切到 Astra Pro 这种高强度模式,体验才稍微好一点。 当然,


MBD数字化定义(十七)—— 3D标注工程实践——注释平面、捕获与视图管理
我是慎独2026/10/17

第17章 3D标注工程实践——注释平面、捕获与视图管理 ——从MBD语义空间到可读性约束的工程化推演 本章聚焦基于模型的定义(Model-Based Definition, MBD)环境下产品制造信息(PMI)的组织与表达。全章以几何线性代数、约束自由度理论与可读性投影模型为分析工具,将原本依赖经验的"3D标注怎么放"问题,转化为可形式化、可断言、可校验的工程决策序列。 学习目标 掌握3D标注的完整工作流程:从功能分析、基准体系确定,到注释平面规划、逐项标注、组合视图组织,直至模型检查与发


Linux网络编程入门(一):从网络协议分层到Socket编程基础
zincsweet2026/10/13

1 网络基础概念 目录 计算机网络背景初识协议协议分层:OSI 七层模型TCP/IP 五层(四层)模型再识协议:为什么要有 TCP/IP网络传输基本流程:局域网通信原理数据的封装与分用跨网络传输:认识 IP 地址与路由器Socket 编程预备 1. 源 IP 与目的 IP2. 端口号3. 传输层典型代表:TCP 与 UDP4. 网络字节序5. socket 编程接口 一、计算机网络背景 1.1 网络发展 计算机网络的发展经历了以下几个阶段: 阶段说明独立模式计算机之间相互


这几天,我都是拿手机让dot帮我干活
老金带你玩AI2026/10/5

这两天,老金我一直在用OpenAI刚推出的个人助手dot,真的是越用越喜欢啊。 原因是啥呢?对于我这种懒人来说,它简直有点贾维斯那意思了。想到什么,拿手机跟它说说,它就去忙。我不用一直坐在电脑面前守着,也不用等一个项目彻底做完,才开始说下一件。 而且它能用的电脑,还不止一台。 它自己有一台云电脑,也能连上我的本地电脑,两边可以同时干活。像查资料、找社区里的帖子、处理GitHub里的代码,这些可以交给云端。我的数字人项目要用到本机的5090,那就放在自己的电脑上跑。 我这边还是拿着手机,跟同一个d


第 27 章 案例三 自动化工作流 Agent
前端阿凡2026/9/27

第 27 章 案例三:自动化工作流 Agent 本章要解决的问题 每周要花 3 小时的报表生成,交给 Agent 自动跑——规划、多智能体、成本优化怎么配合? 章节大纲 27.1 多步骤任务拆解(规划 + 多智能体) 27.2 MCP 集成办公套件(豆包) 27.3 成本优化与异常恢复 27.4 全流程编排与监控 🛠 解决方案:自动化任务失败自愈机制 + 成本预算控制 27.1 场景与任务拆解 27.1.1 场景:周报自动生成 业务:某运营团队每周要生成一份经营周报,人工耗时 3 小时


Kotlin 协程闯关:看代码,猜结果
潜龙勿用之化骨龙2026/9/21

前言 这不是一篇 API 速查表。 接下来 10 关,每一关都先别急着运行。 先凭直觉判断,再打开 IntelliJ IDEA 验证,最后回头看协程到底是怎么运行的。 闯关规则 不要直接复制代码运行,先预测结果。 尽量不要查 API,看看自己对协程调度、挂起和生命周期到底掌握了多少。 在 IntelliJ IDEA 中逐关运行验证。 对照解析,看看自己能走到第几关。 Kotlin 协程闯关地图 10 关协程挑战 从 launch、delay,一路闯到结构化并发与生命周期。


面试总被问云存储?块 / 对象 / 文件存储、快照备份一次性讲透
KIDULT°2026/9/12

华为云存储云服务 摘要:在云时代,存储是云业务的基石。日常我们接触 U 盘、移动硬盘、网盘都是存储设备,上云之后,华为云提供了四类主流存储服务:云硬盘 EVS、对象存储 OBS、弹性文件服务 SFS、云备份 CBR。本文带你搞懂各类存储的概念、特性、区别以及适用场景。 一、什么是存储云服务 存储是指将数据或信息保存在计算机或其他电子设备中的过程。存储可以是临时的,也可以是长期的,例如将文件保存在硬盘驱动器或云存储中。存储是计算机系统中非常重要的组成部分,它不但可以储存数据,还能通过存储实现容


hadoop高可用架构
kuroomi2026/9/4

hadoop高可用 IP 主机名 角色 192.168.150.172 server1 NameNode DFSZKFailoverController ResourceManager 192.168.150.173 server2 JournalNode QuorumPeerMain DataNode NodeManager

首页编辑器站点地图

本站内容在 CC BY-SA 4.0 协议下发布

Copyright © 2026 聚合阅读