map[string]string与map[string]inerface{}的问题

map[string]interface{}和map[string]string是不同的类型，不能直接转换。

或者你可以用接口来实现

type Map interface {
    Value(string) interface{}
}

type StringMap map[string]string

func (m StringMap) Value(key string) interface{} {
    return m[key]
}

func f(m Map) {
    str, ok := m.Value("hello").(string)
    if ok {
        fmt.Println(str)
    }
}

func main() {
    m := map[string]string{}
    m["hello"] = "world"
    f(StringMap(m))
}

如果要支持遍历，就稍微复杂一些：

import (
    "fmt"
)

type Map interface {
    Value(string) interface{}
    Next() (string, interface{}, bool)
}

type StringMap struct {
    m     map[string]string
    keys  []string
    index int
}

func NewStringMap(m map[string]string) *StringMap {
    keys := make([]string, len(m))
    i := 0
    for k, _ := range m {
        keys[i] = k
        i++
    }
    return &StringMap{
        m:     m,
        keys:  keys,
        index: 0,
    }
}

func (m *StringMap) Value(key string) interface{} {
    return m.m[key]
}

func (m *StringMap) Next() (string, interface{}, bool) {
    if m.index >= len(m.keys) {
        return "", nil, false
    }
    key := m.keys[m.index]
    m.index++
    return key, m.m[key], true
}

func f(m Map) {
    for {
        k, v, ok := m.Next()
        if !ok {
            break
        }
        fmt.Printf("%s=%v\n", k, v)
    }
}

func main() {
    m := map[string]string{}
    m["hello"] = "world"
    f(NewStringMap(m))
}

多谢大神的指点！！膜拜～～

我也请教，map[string]inerface{}怎样转ch成map[string]string

简单遍历转换就好了吧，为啥要搞的这么复杂？

package main

import "fmt"

func mapInterface(m map[string]interface{}) {
    for key, v := range m {
        fmt.Println(key, ":", v)
    }
}
func main() {
    mapString := map[string]string{
        "abc": "123",
        "def": "456",
    }
    mapInterface(func(m map[string]string) map[string]interface{} {
        mi := map[string]interface{}{}
        for k, v := range m {
            mi[k] = v
        }
        return mi
    }(mapString))
}

这个样子，是不是满足题意？

type Map interface {
    Value(string) interface{}
    Next() (string, interface{}, bool)
}