标签: go-map

我们有以下功能：

func (h *Handler) Handle(message interface{}) error {
    //here there is a switch for different messages
    switch m := message.(type) {
    }
}

此签名已提供且无法更改。处理程序处理大约 20 种不同的消息类型。

现在，有一些消息（大约 4 个）需要特殊的后处理。在不同的包中。

因此，我想这样做：

 func (h *Handler) Handle(message interface{}) error {
        //here there is a switch for different messages

        switch m := message.(type) {
        }
        //only post-process if original message processing succeeds
        postProcessorPkg.Process(message)
    }

现在，在Process函数中，我想快速查找消息类型是否确实是我们需要后处理的类型。我不想在switch这里再做一次。有许多处理程序，在不同的包中，具有不同数量的消息类型，并且应该是通用的。

所以我想在后处理器中注册消息类型，然后进行查找：

func (p *Postprocessor) Register(msgtype interface{}) {
     registeredTypes[msgtype] = msgtype
}

进而

func (p *Postprocessor) …

这个问题已经用许多其他语言得到了回答。在带有简单映射（无嵌套）的 golang 中，如何确定一个映射是否是另一个映射的子集。例如：map[string]string{"a": "b", "e": "f"}是 的子集map[string]string{"a": "b", "c": "d", "e": "f"}。我想要一个通用方法。我的代码：

package main

import (
    "fmt"
    "reflect"
)

func main() {
    a := map[string]string{"a": "b", "c": "d", "e": "f"}
    b := map[string]string{"a": "b", "e": "f"}
    c := IsMapSubset(a, b)
    fmt.Println(c)
}

func IsMapSubset(mapSet interface{}, mapSubset interface{}) bool {

    mapSetValue := reflect.ValueOf(mapSet)
    mapSubsetValue := reflect.ValueOf(mapSubset)

    if mapSetValue.Kind() != reflect.Map || mapSubsetValue.Kind() != reflect.Map {
        return false
    }
    if reflect.TypeOf(mapSetValue) != reflect.TypeOf(mapSubsetValue) {
        return false
    }
    if …

我想将JSON文件解析为map[string]interface{}：

var migrations map[string]interface{}
json.Unmarshal(raw, &migrations)

fmt.Println(migrations["create_user"])

但是我修改了代码以将数据指向interface{}：

var migrations interface{}
json.Unmarshal(raw, &migrations)

// compile wrong here
fmt.Println(migrations["create_user"])

我不明白很多关于之间的差异map[string]interface{}，并interface{}在上述情况下。

地图中struct的默认值是多少？如何检查地图值是否已初始化？

type someStruct struct { 
    field1 int
    field2 string
}
var mapping map[int]someStruct

func main() {
    mapping := make(map[int]someStruct)
}

func check(key int) {
    if mapping[key] == ? {}
}

我应该检查nil还是someStruct{}？

Go 映射是对内部数据的引用。这意味着当“复制”地图时，它们最终会共享相同的参考并因此编辑相同的数据。这与使用具有相同项目的另一张地图大不相同。但是，我找不到任何方法来区分这两种情况。

import "fmt"
import "reflect"

func main() {
    a := map[string]string{"a": "a", "b": "b"}
    // b references the same data as a
    b := a
    // thus editing b also edits a
    b["c"] = "c"
    // c is a different map, but with same items
    c := map[string]string{"a": "a", "b": "b", "c": "c"}

    reflect.DeepEqual(a, b) // true
    reflect.DeepEqual(a, c) // true too
    a == b // illegal
    a == c // illegal too
    &a == &b // false
    &a …

我正在尝试从 C++ 调用 Go。我的代码在地图上运行，我似乎无法使地图与 cgo 一起使用。

main.go：

package main

import (
    "C"
    "fmt"
)

func main() {}

//export PrintMap
func PrintMap(m map[string]string) {
    fmt.Println(m)
}

其中“编译”为main.h：

typedef void *GoMap;

extern void PrintMap(GoMap p0);

如何在我的 c++ 代码中成功创建 GoMap 并将其传递给 go 代码？

为什么这段代码有效

graph := make(map[int][]int, 0)

graph[0] = append(graph[0], 1)

但是,如果你用graph := make([][]int, 0)我得到的第一行替换panic: runtime error: index out of range？这很奇怪.