# 前言
**迭代器模式**是一种**行为设计模式**，它让我们能在不暴露集合底层表现形式（如列表、栈、树等）的情况下，**顺序访问**一个聚合对象中的各个元素。

其核心思想是**将遍历集合的责任分离出来**，封装到一个独立的“迭代器”对象中。
![Gemini_Generated_Image_w6l41qw6l41qw6l4.png](https://developer.qcloudimg.com/http-save/yehe-1367556/7af670abeef07ff26ffc4fa0cebef8c0.png)
# 问题
我们在软件开发过程中经常会遇到下面这些问题：

1. **遍历代码的重复与臃肿**：同一个集合（比如一个用户列表）在代码的多个地方都需要被遍历。每次我们都写一遍 `for` 循环，不仅**代码重复**，而且一旦集合的内部结构发生变化（比如从数组改为链表），所有遍历它的地方都需要修改。

2. **客户端与具体集合类紧耦合**：客户端代码为了遍历，必须知道集合的具体类型（是 `Slice`、`Map` 还是自定义的 `Tree`），并调用其特定的方法。这违反了**依赖倒置原则**，使得代码难以复用和扩展。

3. **需要支持多种遍历方式**：一个集合可能需要支持前序遍历、后序遍历、广度优先遍历、按条件过滤遍历等多种方式。如果将这些逻辑都塞进集合类里，会导致这个类的**职责过重**，违背单一职责原则。

4. **无法同时进行多个遍历**：如果我们想在遍历一个集合的同时，在另一个线程中也对其进行遍历，或者需要保存当前的遍历位置以便稍后继续，直接操作集合内部状态会非常麻烦且容易出错。

**核心矛盾**在于：集合的**存储结构**（如何保存数据）和**遍历行为**（如何访问数据）是两种经常变化的不同维度。

将它们混在一起，会导致任何一方的变化都影响到另一方。
# 解决方案
迭代器模式的核心是引入一个**迭代器（Iterator）对象**，它负责：
1. 封装对集合元素的访问细节。
2. 提供一个统一的接口（如 `Next()`, `HasNext()`），让客户端可以顺序访问元素，而无需了解底层数据结构。

**模式的主要角色**：
- **迭代器接口（Iterator）**：声明了遍历集合所需的基本操作，如获取下一个元素、判断是否还有元素等。
- **具体迭代器（Concrete Iterator）**：实现迭代器接口。它内部维护着遍历过程中的当前状态（如当前索引或指针），并知道如何从特定集合中获取下一个元素。
- **集合接口（Collection/Aggregate）**：通常声明一个方法（如 `CreateIterator()`）来返回一个与该集合对应的迭代器对象。
- **具体集合（Concrete Collection）**：实现集合接口，负责创建并返回一个能正确遍历自身的具体迭代器实例。
![Gemini_Generated_Image_prbgakprbgakprbg.png](https://developer.qcloudimg.com/http-save/yehe-1367556/83e9e85479ff8a30f999ae1b550058df.png)
通过这种方式，客户端不再直接与集合交互，而是通过迭代器接口来遍历。这带来了巨大的灵活性：我们可以为同一个集合提供不同的迭代器（正序、逆序、过滤等），而客户端代码无需改变；我们也可以轻松地替换底层集合的实现，只要它返回的迭代器接口不变。
# 应用场景
- **隐藏复杂数据结构的内部细节**：当集合的内部结构非常复杂（如组合模式形成的树、图），你希望向客户端提供一个简单的访问方式，避免暴露其内部复杂性时。

- **为同一集合提供多种遍历方式**：例如，对一个文件系统目录树，你可能需要深度优先遍历（DFS）来搜索文件，也需要广度优先遍历（BFS）来统计目录大小。可以为它创建 `DFSIterator` 和 `BFSIterator`。

- **统一遍历接口，简化客户端代码**：你的代码需要处理多种不同类型的集合（如数据库结果集、内存列表、网络流），但希望用同一套代码逻辑来遍历它们。迭代器接口提供了这种统一性。

- **支持并行遍历**：由于每个迭代器对象都封装了自己的遍历状态，因此可以创建多个迭代器同时对同一个集合进行独立的遍历，这在多线程环境下非常有用。

- **与语言或框架的迭代机制集成**：许多现代编程语言（如Go的 `for range`， Java的 `for-each`， C#的 `foreach`）的内部实现都广泛使用了迭代器模式的思想。
# 代码示例
让我们以Go语言为例，实现一个遍历用户集合的迭代器。Go虽然没有内置的迭代器接口，但我们可以很容易地定义自己的接口和实现。
![迭代器模式UML序列图.png](https://developer.qcloudimg.com/http-save/yehe-1367556/3731be1ad2345fd33887e27e8bc62aad.png)
1. **定义集合元素和迭代器接口**：
```
// user.go
package main

// 集合中的元素
type User struct {
    name string
    age  int
}

// iterator.go
// 迭代器接口
type Iterator interface {
    HasNext() bool
    GetNext() *User
}
```

2. **定义集合接口和具体集合**：
```
// collection.go
// 集合接口
type Collection interface {
    CreateIterator() Iterator
}

// userCollection.go
// 具体集合：一个用户切片
type UserCollection struct {
    users []*User
}

func (uc *UserCollection) CreateIterator() Iterator {
    // 返回一个针对 UserCollection 的具体迭代器
    return &UserIterator{
        users: uc.users,
        index: 0,
    }
}
```

3. **实现具体迭代器**：
```
// userIterator.go
type UserIterator struct {
    users []*User
    index int
}

func (ui *UserIterator) HasNext() bool {
    return ui.index < len(ui.users)
}

func (ui *UserIterator) GetNext() *User {
    if ui.HasNext() {
        user := ui.users[ui.index]
        ui.index++
        return user
    }
    return nil
}
```

4. **客户端使用迭代器进行遍历**：
```
// main.go
func main() {
    // 1. 创建具体集合
    userCollection := &UserCollection{
        users: []*User{
            {name: "Alice", age: 30},
            {name: "Bob", age: 25},
            {name: "Charlie", age: 35},
        },
    }

    // 2. 从集合获取迭代器
    iterator := userCollection.CreateIterator()

    fmt.Println("遍历用户集合：")
    // 3. 使用迭代器统一接口进行遍历，完全不知道底层是切片
    for iterator.HasNext() {
        user := iterator.GetNext()
        fmt.Printf(" - 姓名：%s, 年龄：%d\n", user.name, user.age)
    }

    // 示例：可以轻松创建另一个迭代器，遍历状态是独立的
    fmt.Println("\n再次遍历（迭代器状态独立）：")
    iterator2 := userCollection.CreateIterator()
    for iterator2.HasNext() {
        user := iterator2.GetNext()
        fmt.Printf(" - %s\n", user.name)
    }
}
```
**输出结果**：
```
遍历用户集合：
 - 姓名：Alice, 年龄：30
 - 姓名：Bob, 年龄：25
 - 姓名：Charlie, 年龄：35

再次遍历（迭代器状态独立）：
 - Alice
 - Bob
 - Charlie
```
# 优缺点
## **优点**：


- **单一职责原则**：将繁复的遍历算法从集合类中抽离，使得集合只关注数据存储，迭代器只关注遍历逻辑，两者职责清晰。

- **开闭原则**：要增加新的遍历方式（如反向迭代、过滤迭代），只需实现新的迭代器类即可，无需修改现有集合或客户端代码。

- **简化客户端接口**：客户端只需面对简单的 `HasNext/Next` 接口，无需关心集合底层是数组、链表还是树，**极大降低了耦合度**。

- **支持并行遍历**：可以同时创建多个迭代器对象对同一个集合进行遍历，因为它们各自维护自己的遍历状态。

- **延迟遍历**：迭代器可以按需获取元素（例如从网络或数据库流式读取），这在处理大型数据集时非常高效。
## **缺点**：
- **可能增加系统复杂度**：对于简单的集合（如数组），直接使用 `for` 循环可能比引入迭代器模式更简单、直接。你可能会问：“这是不是杀鸡用牛刀？”确实，对于简单的场景，直接遍历更合适。迭代器模式的价值在**处理复杂数据结构或需要统一遍历接口时**才真正体现。
- **可能降低效率**：与直接访问集合的内部表示相比，通过迭代器接口访问通常会带来一些间接调用的开销。但在绝大多数应用中，这种开销可以忽略不计，而带来的设计收益是巨大的。
# 总结
迭代器模式为我们提供了一种**标准化、解耦的集合访问方式**。它将“如何存储数据”和“如何访问数据”这两个关注点分离，使得两者可以独立演化。

当你发现代码中充斥着针对不同数据结构的、五花八门的遍历逻辑时，或者当你需要为同一个数据结构提供多种遍历路径时，迭代器模式就该上场了。

迭代器模式是一种行为设计模式，它让我们能在不暴露集合底层表现形式（如列表、栈、树等）的情况下，顺序访问一个聚合对象中的各个元素。

迭代器设计模式-使用go语言实现

十倍工程师

编程语言

架构设计

迭代器模式是一种行为设计模式，通过分离集合遍历逻辑与数据结构，实现解耦和灵活访问。它封装遍历细节，提供统一接口，支持多种遍历方式，简化客户端代码，适用于复杂数据结构或需要统一遍历的场景。

数据存储

软件开发

数据结构

文件系统

数据库

Java

AI驱动 智领未来

tencentdb-catalog

对象存储COS新用户低至1元！


5位重磅专家聚焦 AI 时代开发者核心成长需求，带你深入解锁全栈进化、人机协作关键路径！点击报名到场：<a href="https://cloud.tencent.com/developer/salon/salon-2403/signup" target="_blank">https://cloud.tencent.com/developer/salon/salon-2403/signup</a><br/> 
 <img src="https://qcloudimg.tencent-cloud.cn/raw/487c82639d2338df3ef66dfb1450601a.png"/>

腾讯技术创作特训营「年度论坛」正在报名中！

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

迭代器设计模式-使用go语言实现-腾讯云开发者社区-腾讯云

迭代器设计模式-使用go语言实现

迭代器设计模式-使用go语言实现

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐