如何在Go语言中从reflect.Value安全地提取底层值

package main

import (
    "fmt"
    "reflect"
    "strconv" // 引入strconv用于类型转换
)

type Foo struct {
    FirstName string `tag_name:"tag 1"`
    LastName  string `tag_name:"tag 2"`
    Age       int    `tag_name:"tag 3"`
    IsActive  bool   `tag_name:"tag 4"`
    Score     float64 `tag_name:"tag 5"`
}

// inspect函数尝试将结构体字段映射为map[string]string
func inspect(f interface{}) map[string]string {
    m := make(map[string]string)
    val := reflect.ValueOf(f)

    // 如果传入的是指针，需要通过Elem()获取其指向的值
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }

    if val.Kind() != reflect.Struct {
        fmt.Println("Error: input is not a struct or a pointer to a struct")
        return m
    }

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

        // 核心问题：如何正确获取底层值并转换为字符串
        // valueField.String() 对于非字符串类型会返回 "<type Value>"
        // 例如，对于 int 类型的 Age 字段，会输出 "Age : <int Value>"
        // 对于 bool 类型的 IsActive 字段，会输出 "IsActive : <bool Value>"
        // 对于 float64 类型的 Score 字段，会输出 "Score : <float66 Value>"
        m[typeField.Name] = valueField.String() // 这里的处理是错误的
    }
    return m
}

func dump(m map[string]string) {
    for k, v := range m {
        fmt.Printf("%s : %s\n", k, v)
    }
}

func main() {
    f := &Foo{
        FirstName: "Drew",
        LastName:  "Olson",
        Age:       30,
        IsActive:  true,
        Score:     98.5,
    }

    fmt.Println("--- 原始（错误）的inspect函数输出 ---")
    a := inspect(f)
    dump(a)
    fmt.Println()

    fmt.Println("--- 修正后的inspect函数输出 ---")
    b := inspectCorrected(f)
    dump(b)
}

// inspectCorrected 函数使用Kind()判断并正确提取底层值
func inspectCorrected(f interface{}) map[string]string {
    m := make(map[string]string)
    val := reflect.ValueOf(f)

    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }

    if val.Kind() != reflect.Struct {
        fmt.Println("Error: input is not a struct or a pointer to a struct")
        return m
    }

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

        // 根据字段的Kind类型，安全地提取底层值并转换为字符串
        switch valueField.Kind() {
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
            m[typeField.Name] = strconv.FormatInt(valueField.Int(), 10)
        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
            m[typeField.Name] = strconv.FormatUint(valueField.Uint(), 10)
        case reflect.Float32, reflect.Float64:
            m[typeField.Name] = strconv.FormatFloat(valueField.Float(), 'f', -1, 64)
        case reflect.Bool:
            m[typeField.Name] = strconv.FormatBool(valueField.Bool())
        case reflect.String:
            m[typeField.Name] = valueField.String()
        // 可以根据需要添加其他Kind类型的处理，例如Slice, Map, Struct等
        default:
            // 对于不支持直接转换为字符串的类型，可以返回其Kind名称或空字符串
            m[typeField.Name] = fmt.Sprintf("<unsupported kind: %s>", valueField.Kind().String())
        }
    }
    return m
}