跳转至

golang中使用匿名结构体

在一些项目中, 我们会使用json 来将字符串转为结构体,但是很多时候,这种结构体只会用一次,基本上只会用于反序列化, 对于这种只用到一次的结构体, 我们可以使用匿名结构体. 在gin 接收参数的时候会非常有用, 如我们将要接收的json 参数为 

1
2
3
4
5
6
7
{
  "opt": "left", 
  "phoneinfo": [
    {"device_id": 64, "sn": "192.168.110.65:5555"},
    {"device_id": 68, "sn": "192.168.110.164:5555"}
  ]
}
当我们尝试使用json.Unmarshal() 函数将json 字符串转为go中的数据结构时,我们可以有以下几种方式

转化为map

map 结构需要定义key 和value的类型, 对于key 好说, 可以都定义为string, 但是对于value, 从上面的json 结构可以看出, 有字符串,也有整型,这种就不太好定义,谁知道未来会不会有新的类型,所以我们可以无脑的将json 转化为 map[string]interface{} 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
import (
    "encoding/json"
    "fmt"
)

func main() {
    str := `{
        "opt": "left", 
        "phoneinfo": [
            {"device_id": 64, "sn": "192.168.110.65:5555"},
            {"device_id": 68, "sn": "192.168.110.164:5555"}
            ]
        }`
    var s map[string]interface{}

    json.Unmarshal([]byte(str), &s)
    fmt.Printf("%#v", s)
}
这种是可以转换,但是如果要用到里面的数据就比较麻烦, 需要将interface{}做类型转换 如要获取到opt 参数 
1
2
opt := s["opt"].(string)
fmt.Println(opt)

定义具名结构体

还有一种方式是定义一个结构体,用来接收参数 如想要接收上面的json 字符串, 可以定义下面的结构体 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package main

import (
    "encoding/json"
    "fmt"
)

type phoneinfo struct {
    Device_id int    `json:"device_id"`
    Sn        string `json:"sn"`
}

type params struct {
    Opt       string      `json:"opt"`
    Phoneinfo []phoneinfo `json:"phoneinfo"`
}

func main() {
    str := `{
        "opt": "left", 
        "phoneinfo": [
            {"device_id": 64, "sn": "192.168.110.65:5555"},
            {"device_id": 68, "sn": "192.168.110.164:5555"}
            ]
        }`
    var s params
    json.Unmarshal([]byte(str), &s)
    fmt.Printf("%#v\n", s)
    fmt.Println(s.Opt) //left
    fmt.Println(s.Phoneinfo[0].Sn) //192.168.110.65:5555
}

定义匿名结构体

上面定义了两个结构体,但是很明显,这两个结构体只在这里使用一次, 别的地方是不会再用得到的, 所以这时我们也可以使用匿名结构体 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
func main() {
    str := `{
        "opt": "left", 
        "phoneinfo": [
            {"device_id": 64, "sn": "192.168.110.65:5555"},
            {"device_id": 68, "sn": "192.168.110.164:5555"}
            ]
        }`

    var s struct {
        Opt       string `json:"opt"`
        Phoneinfo []struct {
            Device_id int    `json:"device_id"`
            Sn        string `json:"sn"`
        } `json:"phoneinfo"`
    }
    json.Unmarshal([]byte(str), &s)
    fmt.Printf("%#v\n", s)
    fmt.Println(s.Opt)
    fmt.Println(s.Phoneinfo[0].Sn)

}

直接通过 var 变量名 struct {} 来初始化一个匿名结构体变量, 但是如果这种结构需要在多处使用,那还是单独定义一个具名结构体比较好.