Go语言通过接口、channel、闭包等方式实现迭代器模式。①定义Iterator接口及SliceIterator结构体遍历切片；②用goroutine和channel实现惰性求值的IntGenerator；③封装InOrderIterator结构体实现二叉树中序遍历；④利用闭包创建状态捕获的MakeCounter函数，返回递增函数。
在Go语言中，虽然没有像C++或Java那样的显式面向对象语法支持，但依然可以通过接口和闭包优雅地实现迭代器模式。该模式用于顺序访问集合元素，而无需暴露其底层结构。以下是几种常见的实现方式。
使用接口定义迭代器
通过定义一个统一的迭代器接口，可以为不同类型的集合提供一致的遍历方式。
type Iterator interface {
HasNext() bool
Next() interface{}
}
type SliceIterator struct {
slice []interface{}
index int
}
func (it *SliceIterator) HasNext() bool {
return it.index < len(it.slice)
}
func (it *SliceIterator) Next() bool {
if it.HasNext() {
val := it.slice[it.index]
it.index++
return val
}
return nil
}
使用示例：
data := []interface{}{"a", "b", "c"}
iter := &SliceIterator{slice: data, index: 0}
for iter.HasNext() {
fmt.Println(iter.Next())
}
利用Go的range和channel实现惰性迭代
更符合Go习惯的方式是结合goroutine与channel，实现流式、惰性求值的迭代器。
立即学习“go语言免费学习笔记（深入）”；
func IntGenerator(start, end int) <-chan int {
ch := make(chan int)
go func() {
for i := start; i < end; i++ {
ch <- i
}
close(ch)
}()
return ch
}
调用方式简洁自然：
for num := range IntGenerator(1, 5) {
fmt.Println(num)
}
封装结构体实现类型安全的迭代器
针对特定数据结构（如二叉树、链表）可设计专用迭代器，提升类型安全性。
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
type InOrderIterator struct {
stack []TreeNode
curr TreeNode
}
func NewInOrderIterator(root TreeNode) InOrderIterator {
return &InOrderIterator{curr: root}
}
func (it *InOrderIterator) HasNext() bool {
return it.curr != nil || len(it.stack) > 0
}
func (it *InOrderIterator) Next() int {
for it.curr != nil {
it.stack = append(it.stack, it.curr)
it.curr = it.curr.Left
}
node := it.stack[len(it.stack)-1]
it.stack = it.stack[:len(it.stack)-1]
val := node.Val
it.curr = node.Right
return val
}
使用函数式风格的闭包迭代器
利用闭包捕获状态，返回一个每次调用产生下一个值的函数。
func MakeCounter(start, step int) func() int {
current := start
return func() int {
defer func() { current += step }()
return current
}
}
使用方式如下：
next := MakeCounter(1, 2)
for i := 0; i < 5; i++ {
fmt.Println(next()) // 输出 1, 3, 5, 7, 9
}
基本上就这些。Go虽无传统意义上的类与继承，但凭借接口、闭包和channel，完全可以灵活实现迭代器模式，关键是选择合适场景下的最简洁方案。
