Question

程序将接收许多味精，味精具有不同的结构“数据”，因此我定义了味精结构：

type Msg struct {
    MsgType int
    Data interface{}
}
type Data1 struct {
//msg type 1 Data struct
}
type Data2 struct {
//msg type 2 Data struct
}
func (msgStr string) {
    msg := Msg{}
    if err := json.Unmarshal([]byte(msgStr), &msg); err != nil {
        //log err
    }
    switch msg.MsgType{
    case 1:
        //convert msg.Data to a type 1 struct
    case 2:
        //convert msg.Data to a type 2 struct
    }
}

但是打印出msg.Data，它是一个映射，而不是接口{}，所以当我通过msg.Data。（Data1）将其转换为Data1时，得到了一个错误。
所以
1.为什么interface {}会自动转换为地图？
2.如何将其转换为我想要的Data1结构？
3.此场景中的最佳做法是什么。

Answer 1

1。因为它可以看到JSON对象，并且据记录，当将JSON对象存储到map[string]interface{}中时，它成为interface{}（这是唯一可以容纳JSON对象中所有内容的类型）。

2。根据当前情况，您可以将地图的每个字段分配给新的Data1或Data2的相应字段。

3。解决此问题的理想方法是使用json.RawMessage来延迟Data的解码，直到您知道它是什么为止。可以这样处理：

type Msg struct {
  MsgType int
  Data interface{}
}

func (m *Msg) UnmarshalJSON(b []byte) (err error) {
    var tmp struct {
        MsgType int
        Data json.RawMessage
    }
    err = json.Unmarshal(b, &tmp)
    if err != nil {
        return
    }
    m.MsgType = tmp.MsgType
    switch (tmp.MsgType) {
    case 1:
        data := Data1{}
        err = json.Unmarshal(tmp.Data, &data)
        if err != nil {
            return
        }
        m.Data = data
    case 2:
        data := Data2{}
        err = json.Unmarshal(tmp.Data, &data)
        if err != nil {
            return
        }
        m.Data = data
    default:
        return errors.New("invalid DataType")
    }
    return
}

然后您可以直接在json.Unmarshal上调用json.Decode或*Msg，并且其Data将根据需要进行解码。

为什么去json.Unmarshal自动转换接口{}映射

1 个答案: