递归打印任意嵌套结构体需用 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、函数返回值）可忽略此检查
代码示例：简洁可运行的递归打印函数
以下是一个带缩进、深度限制、安全解引用的实现：
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 r
eflect.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())
}}
eflect.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")打印 json tag（适合对比序列化行为） - 对 slice/map 元素，可统一加括号标注类型，如
[]int{1 2}→[](int){1 2}
不复杂但容易忽略。
