如何使用Golang反射打印复杂嵌套结构_Golang reflect递归遍历实现

顺亿

2026-10-17 • 👁 0人浏览过

递归打印任意嵌套结构体需用 reflect.Value 判断 Kind、解引用指针/interface{}、遍历 struct/map/slice，并限制深度（如 >5 时输出“...”）防止无限循环。要用 Go 的

reflect

递归打印任意嵌套结构体（包括 map、slice、指针、interface{} 等），关键在于：判断类型、解引用、递归进入子值，并控制深度避免无限循环。基础思路：用 reflect.Value 逐层展开 Go 反射的核心是

reflect.Value

和

reflect.Type

。对任意值调用

reflect.ValueOf(v)

后，可检查其种类（

Kind()

），再根据种类决定如何继续访问：指针：用

.Elem()

解引用（需确保非空）结构体：遍历字段（

.NumField()

.Field(i)

），注意导出性（仅导出字段可读）切片/数组：用

.Len()

和

.Index(i)

遍历元素 map ：用

.MapKeys()

获取 key 列表，再用

.MapIndex(key)

取 value interface{} ：用

.Elem()

拆包后继续处理（本质是隐式指针）基本类型（int/string/bool等）：直接打印

.Interface()

防止无限递归：加深度限制和地址去重遇到循环引用（如 struct A 包含 *A）或深层嵌套时，不加保护会 panic 或卡死。推荐两种方式：深度计数：每进一层递归 +1，超过阈值（如 10）就停止深入，改打

"..."

地址缓存：用

map[uintptr]bool

记录已访问的

Value.UnsafeAddr()

（仅对可寻址值有效），跳过重复项；对不可寻址值（如 map value、函数返回值）可忽略此检查代码示例：简洁可运行的递归打印函数以下是一个带缩进、深度限制、安全解引用的实现：立即学习 “ go语言免费学习笔记（深入） ”； php版微信js-sdk支付接口类 php版微信js-sdk支付接口类下载

func PrintValue(v interface{}, depth int) {
    if depth > 5 {
        fmt.Print("...")
        return
    }
    rv := reflect.ValueOf(v)
    if !rv.IsValid() {
        fmt.Print("nil")
        return
    }

// 处理指针：解引用并加 *
if rv.Kind() == reflect.Ptr {
    if rv.IsNil() {
        fmt.Print("nil")
        return
    }
    fmt.Print("*")
    PrintValue(rv.Elem().Interface(), depth+1)
    return
}

// 处理 interface{}：递归其底层值
if rv.Kind() == reflect.Interface {
    if rv.IsNil() {
        fmt.Print("nil")
        return
    }
    PrintValue(rv.Elem().Interface(), depth+1)
    return
}

// 基本类型直接输出
switch rv.Kind() {
case reflect.String, reflect.Int, reflect.Int8, reflect.Int16,
     reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8,
     reflect.Uint16, reflect.Uint32, reflect.Uint64,
     reflect.Float32, reflect.Float64, reflect.Bool, reflect.Complex64, reflect.Complex128:
    fmt.Print(rv.Interface())
case reflect.Struct:
    fmt.Print("{")
    for i := 0; i < rv.NumField(); i++ {
        if i > 0 {
            fmt.Print(" ")
        }
        field := rv.Field(i)
        name := rv.Type().Field(i).Name
        fmt.Print(name, ":")
        PrintValue(field.Interface(), depth+1)
    }
    fmt.Print("}")
case reflect.Slice, reflect.Array:
    fmt.Print("[")
    for i := 0; i < rv.Len(); i++ {
        if i > 0 {
            fmt.Print(" ")
        }
        PrintValue(rv.Index(i).Interface(), depth+1)
    }
    fmt.Print("]")
case reflect.Map:
    fmt.Print("map[")
    for i, key := range rv.MapKeys() {
        if i > 0 {
            fmt.Print(" ")
        }
        PrintValue(key.Interface(), depth+1)
        fmt.Print(":")
        PrintValue(rv.MapIndex(key).Interface(), depth+1)
    }
    fmt.Print("]")
default:
    fmt.Print(rv.Kind())
}

} 调用方式：

PrintValue(yourStruct, 0)

。支持嵌套 struct、[]struct、map[string]interface{}、*T 等常见组合。实用建议：调试时更友好地显示字段名和类型真实调试中，光看值不够，常需知道字段名、类型甚至 tag。可在打印结构体字段时补充类型信息：用

rv.Type().Field(i).Type.String()

获取字段类型名用

rv.Type().Field(i).Tag.Get("json")

打印 js on tag（适合对比序列化行为）对 slice/map 元素，可统一加括号标注类型，如

[]int{1 2}

→

[](int){1 2}

不复杂但容易忽略。

相关文章