使用递归函数遍历嵌套数据结构：创建基础函数 traverse 用于处理不同类型元素。使用 switch 语句根据元素类型对其进行处理（如打印整型值或遍历数组和映射）。使用 for 循环遍历嵌套结构并调用 traverse 函数处理每个元素。该函数将以嵌套的方式遍历数据结构，逐个处理子结构并打印其类型和值。

使用 Golang 函数遍历嵌套的数据结构

在 Go 中，递归函数用于遍历嵌套的数据结构。递归函数是指调用自身的函数。通过使用递归，我们可以分层遍历数据结构，逐个处理子结构。

基础函数

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

首先，让我们创建一个基础函数来处理任何类型的元素（例如：int、string、float64）：

func traverse(element interface{}) {
    switch v := element.(type) {
    case int:
        fmt.Println("整型元素：", v)
    case string:
        fmt.Println("字符串元素：", v)
    case float64:
        fmt.Println("浮点数元素：", v)
    case []interface{}:
        fmt.Println("数组元素：")
        for _, item := range v {
            traverse(item)
        }
    case map[interface{}]interface{}:
        fmt.Println("映射元素：")
        for key, value := range v {
            fmt.Println("  键：", key)
            fmt.Println("  值：")
            traverse(value)
        }
    }
}

此函数使用 switch 语句根据元素的类型对其进行处理。不同的类型有不同的处理方式，例如打印整型值或遍历数组和映射。

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

遍历示例

现在，让我们看看如何使用此函数遍历一些嵌套数据结构的示例：

func main() {
    data := []interface{}{
        10,
        "字符串",
        3.14,
        []interface{}{
            20,
            "另一个字符串",
        },
        map[interface{}]interface{}{
            "键1": "值1",
            "键2": []interface{}{
                40,
                "最后一个字符串",
            },
        },
    }

    for _, element := range data {
        traverse(element)
    }
}

在上面示例中：

• 我们创建了一个包含不同类型元素的嵌套切片。
• 我们使用 for 循环遍历切片中的元素。
• 对于每个元素，我们调用 traverse 函数对其进行处理。

输出

输出将类似于：

整型元素： 10
字符串元素： 字符串
浮点数元素： 3.14
数组元素：
  整型元素： 20
  字符串元素： 另一个字符串
映射元素：
  键： 键1
  值： 值1
  键： 键2
  值：
    数组元素：
      整型元素： 40
      字符串元素： 最后一个字符串

如你所见，该函数以嵌套的方式遍历数据结构，打印每个元素的类型和值。