Golang迭代器模式集合遍历与使用方法-Golang-PHP中文网

Golang迭代器模式集合遍历与使用方法

P粉602998670

发布： 2025-09-04 08:23:02

原创

666人浏览过

Go语言通过闭包和函数实现迭代器模式，可遍历集合且不暴露内部结构；Go 1.18支持泛型后能编写通用迭代器；可借助接口统一不同数据结构的遍历方式，适用于切片、二叉树等场景，核心是封装状态、简化调用。

golang迭代器模式集合遍历与使用方法

在Go语言中，虽然没有像C++或Java那样的显式迭代器接口，但通过函数、闭包和接口的组合，可以优雅地实现迭代器模式。这种模式适用于需要遍历集合对象且不暴露其内部结构的场景，比如遍历树、链表或自定义数据结构。

基本迭代器设计思路

Go中的迭代器通常通过函数返回一个无参数、返回值为元素和布尔值的闭包来实现。每次调用该函数，返回下一个元素和是否还有元素的标志。

以一个整型切片为例：

func intSliceIterator(slice []int) func() (int, bool) {
    index := 0
    return func() (int, bool) {
        if index >= len(slice) {
            return 0, false
        }
        val := slice[index]
        index++
        return val, true
    }
}

登录后复制

使用方式如下：

立即学习“go语言免费学习笔记（深入）”；

iter := intSliceIterator([]int{1, 2, 3})
for {
    val, hasNext := iter()
    if !hasNext {
        break
    }
    fmt.Println(val)
}

登录后复制

泛型迭代器（Go 1.18+）

Go 1.18引入泛型后，可以编写通用的迭代器，适用于任意类型集合。

func sliceIterator[T any](slice []T) func() (T, bool) {
    index := 0
    return func() (T, bool) {
        var zero T
        if index >= len(slice) {
            return zero, false
        }
        val := slice[index]
        index++
        return val, true
    }
}

登录后复制

调用时指定类型或由编译器推导：

Getfloorplan

创建 2D、3D 平面图和 360° 虚拟游览，普通房间变成梦想之家

148

查看详情

iter := sliceIterator([]string{"a", "b", "c"})
for val, ok := iter(); ok; {
    fmt.Println(val)
}

登录后复制

结构体集合的迭代器实现

对于复杂数据结构，如二叉树，迭代器能隐藏遍历逻辑。

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func inorderIterator(root *TreeNode) func() (int, bool) {
    stack := []*TreeNode{}
    current := root

    return func() (int, bool) {
        for current != nil || len(stack) > 0 {
            for current != nil {
                stack = append(stack, current)
                current = current.Left
            }
            current = stack[len(stack)-1]
            stack = stack[:len(stack)-1]
            val := current.Val
            current = current.Right
            return val, true
        }
        return 0, false
    }
}

登录后复制

中序遍历二叉树变得简洁：

iter := inorderIterator(root)
for val, hasNext := iter(); hasNext; {
    fmt.Println(val)
}

登录后复制

接口方式统一迭代行为

定义统一的迭代器接口，便于在不同集合间切换：

type Iterator[T any] interface {
    Next() (T, bool)
}

type SliceIterator[T any] struct {
    slice []T
    index int
}

func (it *SliceIterator[T]) Next() (T, bool) {
    var zero T
    if it.index >= len(it.slice) {
        return zero, false
    }
    val := it.slice[it.index]
    it.index++
    return val, true
}

登录后复制

使用接口后，调用逻辑更清晰：

var iter Iterator[int] = &SliceIterator[int]{slice: []int{1, 2, 3}}
for val, ok := iter.Next(); ok; {
    fmt.Println(val)
}

登录后复制

基本上就这些。Go的迭代器靠闭包和函数返回实现最常见，泛型加持后更灵活。接口方式适合大型项目统一抽象，而简单场景用闭包就够了。关键是把遍历状态封装好，调用方无需关心内部怎么走。

以上就是Golang迭代器模式集合遍历与使用方法的详细内容，更多请关注php中文网其它相关文章！

大家都在看：

从Java面向对象到Go语言：理解并实践Go的接口与组合模式如何将Java的面向对象特性转换为Go语言实现从Java面向对象到Go接口与组合：多态性表达的范式转换 Google App Engine Go运行时：特性、限制与最佳实践 Go语言中游戏对象组合与类型识别的策略