Golang如何实现反射遍历嵌套结构体_Golang 嵌套结构体遍历实践

package main

import (
    "fmt"
    "reflect"
)

// Person 结构体包含基本信息和地址
type Person struct {
    Name    string
    Age     int
    Address Address
    Contact *ContactInfo // 指针类型嵌套
    ID      int `json:"id_number"` // 带有tag的字段
}

// Address 嵌套结构体
type Address struct {
    Street  string
    City    string
    ZipCode string
}

// ContactInfo 另一个嵌套结构体，通过指针引用
type ContactInfo struct {
    Email string
    Phone string
}

// traverseStruct 递归遍历结构体
func traverseStruct(data interface{}, indent string) {
    val := reflect.ValueOf(data)
    typ := reflect.TypeOf(data)

    // 如果传入的是指针，我们需要获取它指向的值
    if val.Kind() == reflect.Ptr {
        if val.IsNil() {
            fmt.Printf("%s(nil pointer)\n", indent)
            return
        }
        val = val.Elem()
        typ = typ.Elem()
    }

    // 确保我们处理的是一个结构体
    if val.Kind() != reflect.Struct {
        fmt.Printf("%sValue is not a struct, kind: %s, value: %v\n", indent, val.Kind(), val.Interface())
        return
    }

    fmt.Printf("%sStruct Type: %s\n", indent, typ.Name())

    for i := 0; i < val.NumField(); i++ {
        field := val.Field(i)
        fieldType := typ.Field(i)

        fmt.Printf("%s  Field: %s (Type: %s, Tag: %s)", indent, fieldType.Name, fieldType.Type, fieldType.Tag.Get("json"))

        // 处理不同类型的字段
        switch field.Kind() {
        case reflect.Struct:
            fmt.Printf(" -> Nested Struct:\n")
            traverseStruct(field.Interface(), indent+"    ") // 递归调用
        case reflect.Ptr:
            if field.IsNil() {
                fmt.Printf(" -> nil pointer\n")
            } else {
                // 如果是指针指向结构体，解引用后递归
                if field.Elem().Kind() == reflect.Struct {
                    fmt.Printf(" -> Pointer to Nested Struct:\n")
                    traverseStruct(field.Interface(), indent+"    ")
                } else {
                    fmt.Printf(" -> Value: %v (Dereferenced Type: %s)\n", field.Elem().Interface(), field.Elem().Kind())
                }
            }
        case reflect.Slice, reflect.Array:
            fmt.Printf(" -> Slice/Array (Len: %d):\n", field.Len())
            for j := 0; j < field.Len(); j++ {
                elem := field.Index(j)
                if elem.Kind() == reflect.Struct || (elem.Kind() == reflect.Ptr && elem.Elem().Kind() == reflect.Struct) {
                    fmt.Printf("%s      Element %d:\n", indent, j)
                    traverseStruct(elem.Interface(), indent+"        ")
                } else {
                    fmt.Printf("%s      Element %d: %v\n", indent, j, elem.Interface())
                }
            }
        case reflect.Map:
            fmt.Printf(" -> Map (Len: %d):\n", field.Len())
            for _, key := range field.MapKeys() {
                value := field.MapIndex(key)
                if value.Kind() == reflect.Struct || (value.Kind() == reflect.Ptr && value.Elem().Kind() == reflect.Struct) {
                    fmt.Printf("%s      Key: %v, Value:\n", indent, key.Interface())
                    traverseStruct(value.Interface(), indent+"        ")
                } else {
                    fmt.Printf("%s      Key: %v, Value: %v\n", indent, key.Interface(), value.Interface())
                }
            }
        default:
            fmt.Printf(" -> Value: %v\n", field.Interface())
        }
    }
}

func main() {
    p := Person{
        Name: "Alice",
        Age:  30,
        Address: Address{
            Street:  "123 Main St",
            City:    "Anytown",
            ZipCode: "12345",
        },
        Contact: &ContactInfo{
            Email: "alice@example.com",
            Phone: "123-456-7890",
        },
        ID: 1001,
    }

    fmt.Println("--- Traversing Person Struct ---")
    traverseStruct(p, "")

    fmt.Println("\n--- Traversing Pointer to Person Struct ---")
    traverseStruct(&p, "")

    // 演示一个包含切片和map的复杂结构体
    type ComplexData struct {
        ID       string
        Items    []Item
        Settings map[string]Setting
    }

    type Item struct {
        Name  string
        Value float64
    }

    type Setting struct {
        Key   string
        Value string
    }

    cd := ComplexData{
        ID: "comp-001",
        Items: []Item{
            {Name: "ItemA", Value: 10.5},
            {Name: "ItemB", Value: 20.0},
        },
        Settings: map[string]Setting{
            "theme": {Key: "theme", Value: "dark"},
            "lang":  {Key: "lang", Value: "en"},
        },
    }
    fmt.Println("\n--- Traversing ComplexData Struct ---")
    traverseStruct(cd, "")

    // 演示一个nil指针的情况
    var nilContact *ContactInfo
    fmt.Println("\n--- Traversing nil ContactInfo Pointer ---")
    traverseStruct(nilContact, "")
}