Golang Iter迭代器模式实现

我在学习Golang设计模式时遇到了Iter迭代器模式的实现问题。想请教大家：在Golang中如何优雅地实现一个类型安全的迭代器？标准库没有提供类似Java的Iterator接口，这种情况下应该怎样设计？是需要定义一个包含Next()和HasNext()方法的接口，还是说有更符合Go习惯的写法？能否提供一个完整的示例代码，包括如何通过for循环遍历自定义集合？特别想知道在Go中处理这种场景时有哪些最佳实践和需要注意的坑。

2 回复

在Golang中实现迭代器模式，可以通过接口定义迭代行为，让不同类型的数据结构实现统一遍历方式。

核心实现：

  1. 定义迭代器接口：
type Iterator interface {
    HasNext() bool
    Next() interface{}
}
  1. 具体迭代器实现：
type SliceIterator struct {
    data  []interface{}
    index int
}

func (s *SliceIterator) HasNext() bool {
    return s.index < len(s.data)
}

func (s *SliceIterator) Next() interface{} {
    if s.HasNext() {
        val := s.data[s.index]
        s.index++
        return val
    }
    return nil
}
  1. 容器接口：
type Container interface {
    GetIterator() Iterator
}
  1. 具体容器：
type SliceContainer struct {
    data []interface{}
}

func (s *SliceContainer) GetIterator() Iterator {
    return &SliceIterator{
        data:  s.data,
        index: 0,
    }
}

使用示例：

container := &SliceContainer{data: []interface{}{1, "hello", 3.14}}
iter := container.GetIterator()

for iter.HasNext() {
    fmt.Println(iter.Next())
}

优点：

  • 统一遍历接口
  • 隐藏底层数据结构
  • 支持多种遍历方式

这种模式在集合类库中很常见，能让客户端代码与具体数据结构解耦。

更多关于Golang Iter迭代器模式实现的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在 Go 语言中，迭代器模式可以通过接口和结构体来实现，用于遍历集合元素而不暴露其内部结构。以下是一个简单的实现示例：

1. 定义迭代器接口：

type Iterator interface {
    HasNext() bool
    Next() interface{}
}

2. 定义集合接口和具体实现：

type Collection interface {
    CreateIterator() Iterator
}

type BookCollection struct {
    books []string
}

func (b *BookCollection) CreateIterator() Iterator {
    return &BookIterator{books: b.books, index: 0}
}

3. 实现具体迭代器：

type BookIterator struct {
    books []string
    index int
}

func (b *BookIterator) HasNext() bool {
    return b.index < len(b.books)
}

func (b *BookIterator) Next() interface{} {
    if b.HasNext() {
        book := b.books[b.index]
        b.index++
        return book
    }
    return nil
}

4. 使用示例：

func main() {
    collection := &BookCollection{books: []string{"Go编程", "设计模式", "算法导论"}}
    iterator := collection.CreateIterator()
    
    for iterator.HasNext() {
        book := iterator.Next()
        fmt.Println(book)
    }
}

输出：

Go编程
设计模式
算法导论

关键点：

  • 通过 Iterator 接口解耦遍历逻辑
  • 集合实现 CreateIterator() 方法返回迭代器
  • 迭代器维护当前遍历位置
  • 支持不同类型集合的统一遍历方式

这种模式适用于需要统一遍历不同数据结构，或隐藏集合内部实现的场景。

回到顶部