Go语言中获取结构体字段名称的反射机制实践

package main

import (
    "fmt"
    "reflect"
)

// User represents a user profile
type User struct {
    FirstName string
    LastName  string
    Age       int
    IsActive  bool
    secret    string // Unexported field
}

// GetStructFieldNames takes an interface{} and returns a slice of its exported struct field names.
// It returns an error if the input is not a struct or a pointer to a struct.
func GetStructFieldNames(s interface{}) ([]string, error) {
    v := reflect.ValueOf(s)

    // If the input is a pointer, dereference it to get the actual struct value.
    if v.Kind() == reflect.Ptr {
        v = v.Elem()
    }

    // Check if the underlying type is a struct.
    if v.Kind() != reflect.Struct {
        return nil, fmt.Errorf("input must be a struct or a pointer to a struct, got %s", v.Kind())
    }

    // Get the reflect.Type to check field exportability.
    t := v.Type()

    names := make([]string, 0, v.NumField())

    // FieldByNameFunc iterates over the fields of the struct.
    // The callback function is called for each field.
    // Returning true from the callback stops the iteration.
    // To get all names, we always return false.
    v.FieldByNameFunc(func(fieldName string) bool {
        // Use t.FieldByName to get StructField information, then check IsExported().
        // This ensures we only collect names of exported fields.
        if sf, ok := t.FieldByName(fieldName); ok && sf.IsExported() {
            names = append(names, fieldName)
        }
        return false // Continue iterating over all fields
    })

    return names, nil
}

func main() {
    user := User{
        FirstName: "John",
        LastName:  "Doe",
        Age:       30,
        IsActive:  true,
        secret:    "hidden", // This is an unexported field
    }

    fmt.Println("--- Testing with struct instance ---")
    fieldNames, err := GetStructFieldNames(user)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Exported field names of User:", fieldNames)
    }

    fmt.Println("\n--- Testing with pointer to struct ---")
    fieldNamesPtr, err := GetStructFieldNames(&user)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Exported field names of User (via pointer):", fieldNamesPtr)
    }

    fmt.Println("\n--- Testing with a non-struct type ---")
    _, err = GetStructFieldNames("hello Go")
    if err != nil {
        fmt.Println("Error for non-struct input:", err)
    }

    fmt.Println("\n--- Testing with an empty struct ---")
    type EmptyStruct struct{}
    empty := EmptyStruct{}
    emptyFieldNames, err := GetStructFieldNames(empty)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Exported field names of EmptyStruct:", emptyFieldNames)
    }
}