Go原生无迭代器接口，但可用函数值（callback）或通道（chan）模拟：前者轻量同步、靠返回bool控制终止；后者惰性可暂停、需显式关闭且不可重用。

Go 语言原生不支持传统意义上的迭代器接口（如 Java 的 Iterator 或 Python 的 __iter__），也没有 for...of 语法糖；但你可以用函数值、闭包和通道（chan）两种主流方式模拟出安全、可控、可组合的遍历行为。

用函数值（callback）实现轻量级集合遍历

这是最简单、零内存分配、无 goroutine 开销的方式，适合同步、一次性遍历场景。核心是把“对每个元素做什么”作为参数传入。

常见错误是试图在 callback 中提前退出循环（比如想 break），但 Go 没有从外层函数中中断 callback 执行的语法——只能靠返回布尔值约定是否继续：

• 定义遍历函数签名：接受集合（如 []int）和类型为 func(int) bool 的回调，返回 bool 表示是否应终止
• 遍历时若 callback 返回 false，立即 return
• 避免在 callback 中修改原切片底层数组，否则可能引发并发读写 panic（即使单 goroutine，range 期间 append 也可能扩容）

func IterateInts(data []int, fn func(int) bool) {
    for _, v := range data {
        if !fn(v) {
            return
        }
    }
}
// 使用示例：找到第一个偶数就停
found := false
IterateInts([]int{1, 3, 4, 5}, func(v int) bool {
if v%2 == 0 {
fmt.Println("first even:", v)
found = true
return false // 终止遍历
}
return true
})

用 channel 实现惰性、可暂停的迭代器

当你需要类似 Python 生成器的行为（如分页拉取、流式处理、与 select 配合），chan 是更贴近“迭代器模式”的选择。它天然支持协程间解耦、背压（通过缓冲区）和取消。

关键注意点：

• 必须显式关闭 channel，否则 range 会永远阻塞
• 不要在发送端 panic 后忽略 recover，否则接收方可能收不到 close 信号
• 若集合很大，用带缓冲的 channel（如 make(chan int, 64)）能减少 goroutine 切换开销
• 无法 rewind 或重复遍历——channel 是一次性消费的

func IntIterator(data []int) <-chan int {
    ch := make(chan int)
    go func() {
        defer close(ch)
        for _, v := range data {
            ch <- v
        }
    }()
    return ch
}
// 使用
for v := range IntIterator([]int{10, 20, 30}) {
fmt.Println(v)
}

如何支持泛型集合（Go 1.18+）

泛型让迭代器可以复用于任意类型，但要注意：泛型函数本身不能直接返回具体 channel 类型（如 chan T），因为调用时类型未定；必须用类型参数约束 channel 元素。

典型结构是定义一个泛型函数，返回 ，并确保内部 goroutine 正确处理类型：

• 函数签名必须带类型参数，如 func Iterator[T any](data []T)
• 不能对 T 做不安全操作（如假设是 struct 就访问字段），除非加约束（interface{ ID() int }）
• 若集合是 map，需先转成 key/value 切片再发，因为 map 遍历顺序不保证，且无法 range map 在 goroutine 外部安全获取

func Iterator[T any](data []T) <-chan T {
    ch := make(chan T)
    go func() {
        defer close(ch)
        for _, v := range data {
            ch <- v
        }
    }()
    return ch
}
// 使用
for s := range Iterator([]string{"a", "b", "c"}) {
fmt.Println(s)
}

为什么不用 interface{ Next() bool } 这类经典迭代器接口？

Go 社区普遍回避这种设计，因为：

• 每次调用 Next() + Value() 至少两次方法调用，有接口动态调度开销
• 状态管理容易出错（如忘记检查 Next() 返回值就调 Value()）
• 无法与 Go 的 range、select、for...range chan 原生语法协作
• 标准库中 database/sql.Rows 等少数类型用了类似模式，但那是为封装资源生命周期，不是通用遍历抽象

真正需要多态遍历逻辑时，优先考虑函数值或 channel —— 它们更符合 Go 的组合哲学，也更容易测试和调试。复杂状态（如树的中序遍历）才值得单独封装成 struct + 方法，但依然建议用 channel 输出结果而非暴露 Next/Value。