Golang如何使用reflect获取map键值对_Golang reflect map键值对实践

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 示例1: map[string]interface{}
    myMap := map[string]interface{}{
        "name":   "张三",
        "age":    30,
        "city":   "北京",
        "active": true,
    }

    fmt.Println("--- 处理 map[string]interface{} ---")
    processMap(myMap)

    // 示例2: map[int]string
    idMap := map[int]string{
        101: "Alice",
        102: "Bob",
        103: "Charlie",
    }

    fmt.Println("\n--- 处理 map[int]string ---")
    processMap(idMap)

    // 示例3: 一个空map
    emptyMap := make(map[string]int)
    fmt.Println("\n--- 处理空map ---")
    processMap(emptyMap)

    // 示例4: map[string]struct{}
    type User struct {
        ID   int
        Name string
    }
    userMap := map[string]User{
        "admin": {"U001", "Administrator"},
        "guest": {"U002", "Guest User"},
    }
    fmt.Println("\n--- 处理 map[string]struct{} ---")
    processMap(userMap)
}

func processMap(m interface{}) {
    // 首先，把传入的接口{}转换成reflect.Value
    mapValue := reflect.ValueOf(m)

    // 检查是否真的是一个map，或者是否为nil
    if mapValue.Kind() != reflect.Map || !mapValue.IsValid() {
        fmt.Println("输入不是一个有效的map类型或为nil。")
        return
    }

    // 检查map是否为空
    if mapValue.Len() == 0 {
        fmt.Println("map是空的。")
        return
    }

    // 获取所有的键
    keys := mapValue.MapKeys()

    // 遍历键，并获取对应的值
    for _, key := range keys {
        value := mapValue.MapIndex(key)

        // 打印键和值。这里需要注意，key和value都是reflect.Value类型
        // 要获取它们的实际值，需要调用Interface()方法，然后进行类型断言
        fmt.Printf("键类型: %s, 键值: %v | 值类型: %s, 值值: %v\n",
            key.Type().String(), key.Interface(),
            value.Type().String(), value.Interface())
    }
}

// 假设 value 是一个 reflect.Value，代表一个字符串
actualString, ok := value.Interface().(string)
if !ok {
    // 处理类型断言失败的情况，比如打印错误日志或 panic
    fmt.Printf("值不是字符串类型，而是 %T\n", value.Interface())
    return
}
fmt.Printf("成功获取到字符串: %s\n", actualString)

// 假设 value 是一个 reflect.Value，可能代表多种类型
switch v := value.Interface().(type) {
case int:
    fmt.Printf("获取到整数: %d\n", v)
case string:
    fmt.Printf("获取到字符串: %s\n", v)
case bool:
    fmt.Printf("获取到布尔值: %t\n", v)
default:
    fmt.Printf("未知类型的值: %v (类型: %T)\n", v, v)
}

// 这是一个简化的概念性代码，不包含完整的YAML解析器
type MyConfig struct {
    DatabaseURL string `yaml:"db_url"`
    MaxConnections int `yaml:"max_conn"`
}

func LoadConfigFromMap(configMap map[string]interface{}, target interface{}) error {
    targetValue := reflect.ValueOf(target)
    if targetValue.Kind() != reflect.Ptr || targetValue.Elem().Kind() != reflect.Struct {
        return fmt.Errorf("target must be a pointer to a struct")
    }
    elem := targetValue.Elem()
    elemType := elem.Type()

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

        yamlTag := fieldType.Tag.Get("yaml")
        if yamlTag == "" {
            continue // 没有yaml标签的字段跳过
        }

        if configValue, ok := configMap[yamlTag]; ok {
            // 这里需要进行类型匹配和设置
            // 比如：
            if field.CanSet() { // 确保字段是可设置的
                configReflectValue := reflect.ValueOf(configValue)
                if configReflectValue.Type().ConvertibleTo(field.Type()) {
                    field.Set(configReflectValue.Convert(field.Type()))
                } else {
                    // 类型不匹配，可能需要更复杂的转换逻辑
                    fmt.Printf("Warning: Type mismatch for field %s (%s) and config value (%s)\n",
                        fieldType.Name, field.Type(), configReflectValue.Type())
                }
            }
        }
    }
    return nil
}