Dictionary 在地图中存储值和切片

如何在

映射中存储值，映射可以是
类型
和
[]类型

我试过这个：

mymap := make(map[string]interface{})
mymap["string"] = "word"
mymap["vector"] = append(mymap["vector"].([]interface{}), "earth")

但我有一个错误：

panic: interface conversion: interface {} is nil, not []interface {}

这类
mymap
的目的是将其用于
json.marshall
以获取
json
对象，如下所示：

{
    "string": "word",
    "vector": [
        "earth",
        "sun"
    ]
}

这将起作用，但您必须始终手动检查该项是否在映射中，并运行类型断言，并以不同的方式对其进行操作。我建议创建一个类型，并且只使用方法，而不是对地图本身进行操作


您可以通过定义map值的JSON编码处理来完成类似的操作


如果您以前没有在
“vector”
键上设置该值，则该值将是一个非类型化的
nil
，您不能将assert键入任何内容。@mkopriva谢谢，它可以工作！顺便说一句，如果映射的唯一原因是具有特定的json结构，那么定义一个包含两个字段的结构（一个用于字符串，另一个用于向量）将更加明智和实用@mkopriva是一个很好的捕获。。。我的回答有点疯狂，没有停下来思考为什么会这样做，哈哈。
var ErrNotExists = errors.New("value doesn't exist")
var ErrWrongType = errors.New("variable is wrong type")

type MyMap map[string]interface{}

func(m MyMap) IsArray(key string) bool {
    val, ok := m[key]
    if !ok {
        return false
    }
    _, ok = val.([]string)
    return ok
}

func(m MyMap) Exists(key string) bool {
    _, ok := m[key]
    return ok
}

func(m MyMap) SetString(key, value string) {
    m[key] = value
}

func(m MyMap) SetArray(key string, value []string) {
    m[key] = value
}

func(m MyMap) GetString(key string) (string, error) {
    v, ok := m[key]
    if !ok {
        return "", ErrNotExists
    }
    realVal, ok := v.(string)
    if !ok {
        return "", ErrWrongType
    }
    return realVal, nil
}

func(m MyMap) GetArray(key string) ([]string, error) {
    v, ok := m[key]
    if !ok {
        return nil, ErrNotExists
    }
    realVal, ok := v.([]string)
    if !ok {
        return nil, ErrWrongType
    }
    return realVal, nil
}

func(m MyMap) AppendArray(key string, toAppend []string) error {
    v, ok := m[key]
    if !ok {
        return ErrNotExists
    }
    realVal, ok := v.([]string)
    if !ok {
        return ErrWrongType
    }
    m[key] = append(realVal, toAppend...)
    return nil
}

func main() {
    m := make(MyMap)
    m.SetString("string","hello")
    m.SetArray("array",[]string{"hi","there"})
    fmt.Println(m)
    fmt.Println(m.IsArray("string"), m.IsArray("array"))
    s, err := m.GetString("string")
    if err != nil { // handle
        fmt.Println(err)
    }
    a, err := m.GetArray("array")
    if err != nil { // handle
        fmt.Println(err)
    }
    fmt.Println(s,a)
    m.AppendArray("array", []string{"all","you","people"})
    a, err = m.GetArray("array")
    if err != nil { // handle
        fmt.Println(err)
    }
    fmt.Println(a)
}

package main

import (
  "encoding/json"
  "fmt"
)

type MyMap map[string]MyValue

func (m MyMap) Put(k, v string) {
  if list, ok := m[k]; ok {
    m[k] = append(list, v)
  } else {
    m[k] = []string{v}
  }
}

type MyValue []string

func (m MyValue) MarshalJSON() ([]byte, error) {
  if len(m) == 1 {
    return json.Marshal(m[0])
  } else {
    return json.Marshal([]string(m))
  }
}

func main() {
  m := make(MyMap)
  m.Put("string", "word")
  m.Put("vector", "earth")
  m.Put("vector", "sun")
  if data, err := json.Marshal(m); err == nil {
    fmt.Println(string(data))
  }
}