如何在Golang中使用reflect处理结构体嵌套字段_Golang reflect嵌套字段处理方法汇总

package main

import (
    "fmt"
    "reflect"
)

type Address struct {
    City  string
    State string
}

type Person struct {
    Name    string
    Age     int
    Addr    Address  // 嵌套结构体
    Private string   // 小写字段（不可导出）
}

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

    rt := rv.Type()

    for i := 0; i < rv.NumField(); i++ {
        field := rt.Field(i)
        value := rv.Field(i)

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

func main() {
    p := Person{
        Name: "Alice",
        Age:  30,
        Addr: Address{City: "Beijing", State: "China"},
    }
    printFields(p)
}

func walkStruct(v reflect.Value) {
    if v.Kind() == reflect.Ptr {
        v = v.Elem()
    }

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

        if field.Kind() == reflect.Struct {
            walkStruct(field) // 递归处理嵌套结构体
        } else {
            fmt.Printf("找到字段: %s = %v\n", fieldType.Name, field.Interface())
        }
    }
}

func setNestedField(obj interface{}, fieldPath []string, newValue interface{}) error {
    v := reflect.ValueOf(obj)
    if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
        return fmt.Errorf("obj must be a pointer to struct")
    }
    v = v.Elem()

    for _, name := range fieldPath {
        if v.Kind() == reflect.Struct {
            field := v.FieldByName(name)
            if !field.IsValid() {
                return fmt.Errorf("field %s not found", name)
            }
            if !field.CanSet() {
                return fmt.Errorf("field %s is unexported and cannot be set", name)
            }
            v = field
        } else {
            return fmt.Errorf("expected struct, got %s", v.Kind())
        }
    }

    newVal := reflect.ValueOf(newValue)
    if newVal.Type().AssignableTo(v.Type()) {
        v.Set(newVal)
    } else {
        return fmt.Errorf("cannot assign %T to %s", newValue, v.Type())
    }

    return nil
}

p := &Person{}
setNestedField(p, []string{"Addr", "City"}, "Shanghai")
fmt.Println(p.Addr.City) // 输出: Shanghai

type Base struct {
    ID   int
    Name string
}

type User struct {
    Base  // 匿名嵌套
    Email string
}

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

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

        if field.Anonymous {
            fmt.Printf("发现匿名字段: %s\n", field.Name)
            // 可递归处理该字段内容
            if value.Kind() == reflect.Struct {
                for j := 0; j < value.NumField(); j++ {
                    nestedField := value.Type().Field(j)
                    fmt.Printf("  提升字段: %s = %v\n", nestedField.Name, value.Field(j).Interface())
                }
            }
        }
    }
}