Golang结构体反射与字段遍历技巧

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
    Email string `json:"email,omitempty"`
}

func inspectStruct(s interface{}) {
    v := reflect.ValueOf(s)
    // 确保是指针或结构体
    if v.Kind() == reflect.Ptr {
        v = v.Elem()
    }

    if v.Kind() != reflect.Struct {
        fmt.Println("输入必须是结构体")
        return
    }

    t := v.Type()
    for i := 0; i < v.NumField(); i++ {
        field := t.Field(i)
        value := v.Field(i)

        fmt.Printf("字段名: %s, 类型: %s, 值: %v", 
            field.Name, field.Type, value.Interface())

        // 读取标签
        if jsonTag := field.Tag.Get("json"); jsonTag != "" {
            fmt.Printf(", JSON标签: %s", jsonTag)
        }
        fmt.Println()
    }
}

func main() {
    u := User{Name: "Alice", Age: 30, Email: "alice@example.com"}
    inspectStruct(u)
}

func updateField(s interface{}, fieldName string, newValue interface{}) {
    v := reflect.ValueOf(s)
    if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
        fmt.Println("必须传入结构体指针")
        return
    }

    v = v.Elem() // 解引用
    field := v.FieldByName(fieldName)
    if !field.IsValid() {
        fmt.Printf("字段 %s 不存在\n", fieldName)
        return
    }

    if !field.CanSet() {
        fmt.Printf("字段 %s 不可被设置\n", fieldName)
        return
    }

    newVal := reflect.ValueOf(newValue)
    if field.Type() != newVal.Type() {
        fmt.Printf("类型不匹配: 期望 %s, 实际 %s\n", 
            field.Type(), newVal.Type())
        return
    }

    field.Set(newVal)
}

func main() {
    u := &User{Name: "Bob", Age: 25}
    updateField(u, "Name", "Charlie")
    updateField(u, "Age", 35)
    fmt.Printf("%+v\n", *u) // {Name:Charlie Age:35 Email:}
}

type Address struct {
    City  string
    State string
}

type Person struct {
    Name string
    Addr Address
}

func printNestedFields(p interface{}) {
    v := reflect.ValueOf(p)
    if v.Kind() == reflect.Ptr {
        v = v.Elem()
    }

    if v.Kind() != reflect.Struct {
        return
    }

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

        if val.Kind() == reflect.Struct {
            fmt.Printf("进入嵌套结构体: %s\n", field.Name)
            // 递归处理
            printNestedFields(val.Addr().Interface())
        } else {
            fmt.Printf("字段: %s, 值: %v\n", field.Name, val.Interface())
        }
    }
}