Go语言：使用反射动态获取结构体字段名

package main

import (
    "fmt"
    "reflect"
)

// User 定义一个示例结构体
type User struct {
    FirstName string
    LastName  string
    Age       int
    IsActive  bool
    unexportedField string // 未导出字段
}

// GetStructFieldNames 接收一个结构体或结构体指针，返回其所有字段的名称切片
func GetStructFieldNames(s interface{}) ([]string, error) {
    v := reflect.ValueOf(s)

    // 如果是指针，则解引用获取其指向的值
    if v.Kind() == reflect.Ptr {
        v = v.Elem()
    }

    // 确保传入的是结构体类型
    if v.Kind() != reflect.Struct {
        return nil, fmt.Errorf("input must be a struct or a pointer to a struct, got %s", v.Kind())
    }

    // 预分配容量，优化性能
    names := make([]string, 0, v.NumField())

    // 使用FieldByNameFunc遍历所有字段并收集其名称
    // 回调函数返回false以确保遍历所有字段
    v.FieldByNameFunc(func(fieldName string) bool {
        names = append(names, fieldName)
        return false // 返回 false 继续遍历下一个字段
    })

    return names, nil
}

func main() {
    // 示例1: 命名结构体
    user := User{
        FirstName:       "John",
        LastName:        "Doe",
        Age:             30,
        IsActive:        true,
        unexportedField: "secret data",
    }

    fieldNames, err := GetStructFieldNames(user)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("命名结构体User的字段名:", fieldNames)
    // 预期输出: [FirstName LastName Age IsActive unexportedField]

    // 示例2: 匿名结构体
    instance := struct {
        Foo string
        Bar int
        Baz bool
    }{"foo", 123, true}

    anonFieldNames, err := GetStructFieldNames(instance)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("匿名结构体的字段名:", anonFieldNames)
    // 预期输出: [Foo Bar Baz]

    // 示例3: 传入结构体指针
    userPtr := &user
    fieldNamesFromPtr, err := GetStructFieldNames(userPtr)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("通过指针获取User的字段名:", fieldNamesFromPtr)

    // 示例4: 传入非结构体类型
    _, err = GetStructFieldNames("hello")
    if err != nil {
        fmt.Println("尝试传入字符串类型时的错误:", err)
    }
}

package main

import (
    "fmt"
    "reflect"
)

// GetStructFieldDetails 接收一个结构体或结构体指针，返回其所有字段的名称切片
// 并展示如何获取更多字段信息
func GetStructFieldDetails(s interface{}) ([]string, error) {
    t := reflect.TypeOf(s)

    // 如果是指针，则解引用获取其指向的类型
    if t.Kind() == reflect.Ptr {
        t = t.Elem()
    }

    // 确保传入的是结构体类型
    if t.Kind() != reflect.Struct {
        return nil, fmt.Errorf("input must be a struct or a pointer to a struct, got %s", t.Kind())
    }

    var fieldNames []string
    // 循环遍历结构体的每一个字段
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i) // 获取reflect.StructField
        fieldNames = append(fieldNames, field.Name)

        // 可以在此处获取更多字段信息，例如：
        // fmt.Printf("  Name: %s, Type: %s, Tag: %s, Exported: %t\n",
        //     field.Name, field.Type, field.Tag, field.IsExported())
    }
    return fieldNames, nil
}

func main() {
    user := User{
        FirstName:       "Jane",
        LastName:        "Smith",
        Age:             25,
        IsActive:        false,
        unexportedField: "internal",
    }

    fmt.Println("\n--- 使用reflect.Type循环获取字段名及额外信息 ---")
    fieldNamesLoop, err := GetStructFieldDetails(user)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("结构体User的字段名（使用reflect.Type循环）:", fieldNamesLoop)
}