Go语言通过结构体和方法实现迭代器模式，可安全灵活遍历集合；示例包括整型切片迭代器、泛型迭代器及自定义集合StringSet的迭代器，支持统一访问、顺序遍历与逻辑解耦，结合泛型后更通用，但需注意边界和并发安全。
在Go语言中，虽然没有像C++或Java那样的显式接口继承机制来定义标准迭代器，但可以通过结构体和方法组合实现迭代器模式，从而安全、灵活地遍历集合。这种方式能将遍历逻辑与数据结构解耦，适用于自定义容器类型。
什么是迭代器模式
迭代器模式提供一种统一方式访问集合元素，而不暴露其内部表示。它支持顺序访问、中途停止、多遍遍历等场景，同时保持集合封装性。
实现一个简单的切片迭代器
以下是一个针对整型切片的迭代器示例：
type IntSliceIterator struct {
data []int
index int
}
func NewIntSliceIterator(data []int) *IntSliceIterator {
return &IntSliceIterator{data: data, index: 0}
}
func (it *IntSliceIterator) HasNext() bool {
return it.index
}
func (it *IntSliceIterator) Next() int {
if !it.HasNext() {
panic("no more elements")
}
value := it.data[it.index]
it.index++
return value
}
使用方式如下：
立即学习“go语言免费学习笔记（深入）”；
data := []int{1, 2, 3, 4, 5}
it := NewIntSliceIterator(data)
for it.HasNext() {
fmt.Println(it.Next())
}
泛型迭代器（Go 1.18+）
使用泛型可构建通用迭代器，适配多种类型：
type SliceIterator[T any] struct {
data []T
index int
}
func NewSliceIterator[T any](data []T) *SliceIterator[T] {
return &SliceIterator[T]{data: data, index: 0}
}
func (it *SliceIterator[T]) HasNext() bool {
return it.index
}
func (it *SliceIterator[T]) Next() T {
if !it.HasNext() {
var zero T
return zero
}
value := it.data[it.index]
it.index++
return value
}
调用示例：
it := NewSliceIterator([]string{"a", "b", "c"})
for it.HasNext() {
fmt.Println(it.Next())
}
为自定义集合添加迭代器
假设有一个有序集合结构：
type StringSet struct {
items map[string]struct{}
}
func (s *StringSet) Add(str string) {
s.items[str] = struct{}{}
}
func (s *StringSet) Iterator() *StringSetIterator {
keys := make([]string, 0, len(s.items))
for k := range s.items {
keys = append(keys, k)
}
return &StringSetIterator{data: keys, index: 0}
}
对应的迭代器：
type StringSetIterator struct {
data []string
index int
}
func (it *StringSetIterator) HasNext() bool { return it.index
func (it *StringSetIterator) Next() string {
if !it.HasNext() { return "" }
v := it.data[it.index]
it.index++
return v
}
使用：
set := &StringSet{items: make(map[string]struct{})}
set.Add("x"); set.Add("y")
it := set.Iterator()
for it.HasNext() {
fmt.Println(it.Next())
}
基本上就这些。Go通过结构体+方法就能轻松实现迭代器模式，结合泛型后更加通用。这种设计利于测试、扩展和控制遍历过程，比如加入过滤、映射等功能。不复杂但容易忽略细节，比如边界判断和并发安全需自行处理。
