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 < len(it.data)
}

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 < len(it.data)
}

func (it *SliceIterator[T]) Next() T {
  if !it.HasNext() {
    var zero T
    return zero
  }
  value := it.data[it.index]
  it.index++
  return value
}

调用示例：

超级简历WonderCV

免费求职简历模版下载制作，应届生职场人必备简历制作神器

28

查看详情

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 < len(it.data) }
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通过结构体+方法就能轻松实现迭代器模式，结合泛型后更加通用。这种设计利于测试、扩展和控制遍历过程，比如加入过滤、映射等功能。不复杂但容易忽略细节，比如边界判断和并发安全需自行处理。