最佳方式获取通用和动态的 Go 地图内容是什么？

获取通用且动态的 Go 地图内容的最佳方式是利用 JSON 解码和类型切换。通过声明映射将 JSON 变体类型与 Go 类型关联，可以将 JSON 数据解码为原始消息。然后，使用索引中的元素名称创建适当的 Go 类型值并解码为该值。最后，使用类型切换访问消息的变体部分，从而提供灵活且动态的方式来处理不同类型的 JSON 数据。

我有这个 json，我将其转换为：

var leerchat []interface{}

但我正在经历疯狂的循环才能到达该地图上的任何一点，在地图内部和地图疯狂内部，特别是因为某些结果是不同的内容。 这是 json

[
   null,
   null,
   "hub:zwxroom",
   "presence_diff",
   {
      "joins":{
         "f718a187-6e96-4d62-9c2d-67aedea00000":{
            "metas":[
               {
                  "context":{},
                  "permissions":{},
                  "phx_ref":"zndwmfsome=",
                  "phx_ref_prev":"zdmbrtmsome=",
                  "presence":"lobby",
                  "profile":{},
                  "roles":{}
               }
            ]
         }
      },
      "leaves":{}
   }
]

我需要进入个人资料，然后里面有一个“displayname”字段。

所以我一直在做疯狂的黑客..即使这样我也卡在了一半......

首先是一个数组，所以我可以做一些事情[elementnumber] 然后就是棘手的映射开始的时候...... 抱歉，所有打印等都是为了调试并查看我返回的元素数量。

if leerCHAT[3] == "presence_diff" {
                var id string
                presence := leerCHAT[4].(map[string]interface{})
                log.Printf("algo: %v", len(presence))
                log.Printf("algo: %s", presence["joins"])
                vamos := presence["joins"].(map[string]interface{})
                for i := range vamos {
                    log.Println(i)
                    id = i
                }
                log.Println(len(vamos))

                vamonos := vamos[id].(map[string]interface{})
                log.Println(vamonos)
                log.Println(len(vamonos))

                metas := vamonos["profile"].(map[string]interface{})   \\\ I get error here..

                log.Println(len(metas))
            }

到目前为止，我可以一直看到元：{...}，但无法继续使用我的黑客代码来实现我需要的内容。

注意：由于 joins: 之后和 metas: 之前的 id 是动态的，我必须以某种方式获取它，因为它始终只是一个元素，我使用 for range 循环来获取它。

解决方案

索引 3 处的数组元素描述了索引 4 处的变体 json 的类型。

以下是如何将 json 解码为 go 值。首先，为 json 的每个变体部分声明 go 类型：

type prescencediff struct {
     joins map[string]*presence // declaration of presence type to be supplied
     leaves map[string]*presence
}

type message struct {
     body string
}

声明一个将类型字符串与 go 类型关联的映射：

var messagetypes = map[string]reflect.type{
    "presence_diff": reflect.typeof(&presencediff{}),
    "message":       reflect.typeof(&message{}),
    // add more types here as needed
}

将变体部分解码为 raw message。使用索引 3 处元素中的名称来创建适当 go 类型的值并解码为该值：

func decode(data []byte) (interface{}, error) {
    var messagetype string
    var raw json.rawmessage
    v := []interface{}{nil, nil, nil, &messagetype, &raw}
    err := json.unmarshal(data, &v)
    if err != nil {
        return nil, err
    }

    if len(raw) == 0 {
        return nil, errors.new("no message")
    }

    t := messagetypes[messagetype]
    if t == nil {
        return nil, fmt.errorf("unknown message type: %q", messagetype)
    }

    result := reflect.new(t.elem()).interface()
    err = json.unmarshal(raw, result)
    return result, err
}

使用 type switches 访问消息的变体部分：

defer ws.Close()

for {
    _, data, err := ws.ReadMessage()
    if err != nil {
        log.Printf("Read error: %v", err)
        break
    }

    v, err := decode(data)
    if err != nil {
        log.Printf("Decode error: %v", err)
        continue
    }

    switch v := v.(type) {
    case *PresenceDiff:
        fmt.Println(v.Joins, v.Leaves)
    case *Message:
        fmt.Println(v.Body)
    default:
        fmt.Printf("type %T not handled\n", v)
    }
}

Run it on the playground。

好了，本文到此结束，带大家了解了《最佳方式获取通用和动态的 Go 地图内容是什么？》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！