popo

go-doc-json

Posted on Edited on 
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
package main
import (
    "fmt"
    "encoding/json"
)

// 定义一个结构体
type Monster struct {
    Name string `json:"monster_name"` //反射机制
    Age int `json:"monster_age"`
    Birthday string 
    Sal float64
    Skill string
}

// struct的json使用
func marshalStruct() {
    monster := Monster{
        Name :"牛魔王",
        Age : 500 ,
        Birthday : "2011-11-11",
        Sal : 8000.0,
        Skill : "牛魔拳",
    }

    // 将monster 序列化
    data, err := json.Marshal(&monster) //..
    if err != nil {
        fmt.Printf("序列号错误 err=%v\n", err)
    }
    // 输出序列化后的结果
    fmt.Printf("monster序列化后=%v\n", string(data))

}

// map的json使用
func marshalMap() string {
    //定义一个map
    var a map[string]interface{}
    //使用map,需要make
    a = make(map[string]interface{})
    a["name"] = "红孩儿"
    a["age"] = 30
    a["address"] = "洪崖洞"

    //将a这个map进行序列化
    //将monster 序列化
    data, err := json.Marshal(a)
    if err != nil {
        fmt.Printf("序列化错误 err=%v\n", err)
    }
    //输出序列化后的结果
    fmt.Printf("a map 序列化后=%v\n", string(data))

    return string(data)
}

// slice的json使用 []map[string]interface{}
func marshalSlice() {
    var slice []map[string]interface{}
    var m1 map[string]interface{}
    //使用map前，需要先make
    m1 = make(map[string]interface{})
    m1["name"] = "jack"
    m1["age"] = "7"
    m1["address"] = "北京"
    slice = append(slice, m1)

    var m2 map[string]interface{}
    //使用map前，需要先make
    m2 = make(map[string]interface{})
    m2["name"] = "tom"
    m2["age"] = "20"
    m2["address"] = [2]string{"墨西哥","夏威夷"}
    slice = append(slice, m2)

    //将切片进行序列化操作
    data, err := json.Marshal(slice)
    if err != nil {
        fmt.Printf("序列化错误 err=%v\n", err)
    }
    //输出序列化后的结果
    fmt.Printf("slice 序列化后=%v\n", string(data))
    
}

// 基本数据类型的json使用
func marshalFloat64() {
    var num1 float64 = 2345.67

    //对num1进行序列化
    data, err := json.Marshal(num1)
    if err != nil {
        fmt.Printf("序列化错误 err=%v\n", err)
    }
    //输出序列化后的结果
    fmt.Printf("num1 序列化后=%v\n", string(data))
}


// struct反序列化使用
func unmarshalStruct() {
    // 说明str 在项目开发中，是通过网络传输获取到.. 或者是读取文件获取到
    str := "{\"monster_name\":\"牛魔王~~~\",\"monster_age\":500,\"Birthday\":\"2011-11-11\",\"Sal\":8000,\"Skill\":\"牛魔拳\"}"

    //定义一个Monster实例
    var monster Monster

    err := json.Unmarshal([]byte(str), &monster)
    if err != nil {
        fmt.Printf("unmarshal err=%v\n", err)
    }
    fmt.Printf("反序列化后 monster=%v monster.Name=%v \n", monster, monster.Name)
}

// map反序列化使用
func unmarshalMap() {
    // str := "{\"address\":\"洪崖洞\",\"age\":30,\"name\":\"红孩儿\"}"
    str := marshalMap()
    // 定义一个map
    var a map[string]interface{} 

    // 反序列化
    // 注意：反序列化map,不需要make,因为make操作被封装到 Unmarshal函数
    err := json.Unmarshal([]byte(str), &a)
    if err != nil {
        fmt.Printf("unmarshal err=%v\n", err)
    }

    fmt.Printf("反序列化后 a=%v\n", a)
}

// slice反序列化使用
func unmarshalSlice() {
    str := "[{\"address\":\"北京\",\"age\":\"7\",\"name\":\"jack\"}," + 
        "{\"address\":[\"墨西哥\",\"夏威夷\"],\"age\":\"20\",\"name\":\"tom\"}]"
    
    // 定义一个slice
    var slice []map[string]interface{}
    // 反序列化，不需要make,因为make操作被封装到 Unmarshal函数
    err := json.Unmarshal([]byte(str), &slice)
    if err != nil {
        fmt.Printf("unmarshal err=%v\n", err)
    }

    fmt.Printf("反序列化后 slice=%v\n", slice)
}

func main() {
    
    marshalStruct()
    marshalMap()
    marshalSlice()
    marshalFloat64()

    fmt.Printf("\n\n")

    unmarshalStruct()
    unmarshalMap()
    unmarshalSlice()
}