如何在Golang中用反射处理map类型 分享Key和Value的迭代方法

package main

import (
    "fmt"
    "reflect"
)

func iterateMapWithReflection(m interface{}) {
    // 获取传入接口的反射值
    val := reflect.ValueOf(m)

    // 检查反射值的类型是否为map
    if val.Kind() != reflect.Map {
        fmt.Println("Error: Not a map type.")
        return
    }

    fmt.Println("--- Iterating Map ---")
    // 获取map的所有键
    keys := val.MapKeys()

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

        // 将reflect.Value转换回原始接口类型，以便打印或进一步处理
        fmt.Printf("Key: %v, Value: %v\n", key.Interface(), value.Interface())
    }
    fmt.Println("---------------------")
}

func main() {
    myMap := map[string]int{
        "apple":  1,
        "banana": 2,
        "cherry": 3,
    }

    iterateMapWithReflection(myMap)

    // 尝试传入非map类型
    mySlice := []int{1, 2, 3}
    iterateMapWithReflection(mySlice)

    // 传入一个空map
    emptyMap := make(map[string]string)
    iterateMapWithReflection(emptyMap)
}

map[string]interface{}

Interface()

interface{}

package main

import (
    "fmt"
    "reflect"
)

func processMixedTypeMap(m interface{}) {
    val := reflect.ValueOf(m)

    if val.Kind() != reflect.Map {
        fmt.Println("Error: Not a map type.")
        return
    }

    fmt.Println("\n--- Processing Mixed Type Map ---")
    keys := val.MapKeys()

    for _, key := range keys {
        value := val.MapIndex(key)

        // 处理键的类型
        switch k := key.Interface().(type) {
        case string:
            fmt.Printf("Key (string): %s, ", k)
        case int:
            fmt.Printf("Key (int): %d, ", k)
        default:
            fmt.Printf("Key (unknown type): %v, ", k)
        }

        // 处理值的类型
        switch v := value.Interface().(type) {
        case int:
            fmt.Printf("Value (int): %d\n", v)
        case string:
            fmt.Printf("Value (string): %s\n", v)
        case bool:
            fmt.Printf("Value (bool): %t\n", v)
        default:
            fmt.Printf("Value (unknown type): %v\n", v)
        }
    }
    fmt.Println("---------------------------------")
}

func main() {
    mixedMap := map[interface{}]interface{}{
        "name":  "Alice",
        100:     true,
        "age":   30,
        false:   "error",
        "items": []string{"item1", "item2"},
    }

    processMixedTypeMap(mixedMap)
}

key.Interface().(type)

value.Interface().(type)

ok

v, ok := value.Interface().(type)