参考：
https://sanyuesha.com/2018/05/07/go-json/
json 的处理包括序列化，和反序列化
序列化
序列化就是把 go 的对象转化为 json 字符串
用到的包：encoding/json
用到函数 ： Marshal
func Marshal(v interface{}) ([]byte, error)
简单的例子：
type easy struct{
Name string `json:"name"` // 字段解释，可指json 字符串的名字
Age int `json: age`
Like string `json: like`
}
func struct2json(){
json_str, err := json.Marshal(easy{"yxl", 25, "freedom"})
if err != nil{
Println(err)
return
}
Printf("%v", string(json_str))
// > {"name":"yxl","Age":25,"Like":"freedom"}
}
序列化有几个注意的地方：
key 只能是 string 类型
Channel、complex、function 等类型不能被序列化， 和py 差不多的
不可以序列化循环引用的东西
指针序列化为 他指向的值，或者 nil
结构体 的 字段必须是 公开的（首字母大写）
反序列化
反序列化，即把 json 字符串变为
用到的函数：Unmarshal
func Unmarshal(data []byte, v interface{}) error
也弄个例子：
type easy struct{
Name string `json:"name"` // 字段解释，可指json 字符串的名字
Age int `json: age`
Like string `json: like`
}
func json2struct(){
var struct_obj easy
json_str := []byte(`{"name":"yxl","Age":25,"Like":"freedom"}`)
err := json.Unmarshal(json_str, &struct_obj)
if err != nil{
Println(err)
return
}
Printf("%v", struct_obj)
// > {yxl 25 freedom}
}
- 关于 序列化和反序列化 字段名称指定：
就是上面的结构体 字段的 标签了
如：
SomeField stringjson:"some_field"序列化后，字符串字段就叫做 some_field 了 - 使用 tag 后加 ,omitempty 来指定序列化字段为 0值，不添加这个字段
type MyStruct struct {
SomeField string `json:"some_field,omitempty"`
}
m := MyStruct{}
b, err := json.Marshal(m) //{}
- 忽略指定字段
tag 值 为 - 就可以忽略这个字段了
type MyStruct struct {
SomeField string `json:"some_field"`
Passwd string `json:"-"`
}
m := MyStruct{}
b, err := json.Marshal(m) //{"some_feild":""}
反序列化任意数据
var f interface{}
err := json.Unmarshal(b, &f)
把 特定类型改为 interface{ } 就可以啦 （反序列化为 go interface 类型，后面就是操作 interface 的步骤了，常见的就是 断言进行类型转化，然后取值，所以下面进行 了 switch 断言， 如果知道传过来的 数据结构，这个取值断言那就简单了）
func json2struct(){
var struct_obj interface{}
json_str := []byte(`{"name":"yxl","Age":25,"Like":"freedom"}`)
err := json.Unmarshal(json_str, &struct_obj)
if err != nil{
Println(err)
return
}
Printf("%v", struct_obj)
// > map[name:yxl Age:25 Like:freedom]
for k, v := range struct_obj.(map[string]interface{}) {
switch vv := v.(type) {
case string:
Println(k, "is string", vv)
case float64:
Println(k, "is float64", vv)
case []interface{}:
Println(k, "is an array:")
for i, u := range vv {
Println(i, u)
}
default:
Println(k, "is of a type I don't know how to handle")
}
}
> name is string yxl
Age is float64 25
Like is string freedom
}
其实你如果知道发过来的数据格式，那就写一个具体的对象吧，而不是统一 interface
（序列化，你可以使用 任意数据结构，不只是 struct, map slice 都可以， 只是struct 好处是可以根据字段tag 帮你映射 字段名，也有一些额外的操作，比如是不是必须的，等等）
但是一旦你写了 具体的序列化结构，只写你 已经知道的字段类型，不知道的用 通用的 interface 代替（或者同一层级结构 不一致也用 interface { } 统一序列化）如果类型写错了，序列化是会报错的。
比如下面的
var Post_data struct{
// 结果上传的结构
Image_name string `json:"image_name" form:"image_name"`
Task_id string `json:"task_id" form:"task_id"`
Result []map[string] string `json:"result" form:"result"`
}
// 这里的 Result 如果结构清晰，就一级级的往下写（序列化是会递归转为你写的类型
// 的）， 如果不清晰就 直接 用 interface 吧
发序列化例子
{image_name:./data/14.jpg
result:[
{algo_type:3
attributes:{name:正常 score:9.578981399536133 value:0}
child:[]
height:111
score:0.803774356842041
track_id:-1
type:0
type_name:销钉
width:163
x:5152
y:2225}
]
}
var p Post_data
if err := c.Bind(&p); err!= nil{
panic(err)
}
// 下面查看结果
fmt.Printf("类型是：%T \n 值是：%v \n", p.Result[0]["algo_type"], p.Result[0]["algo_type"])
>>
类型是：float64
值是：3
fmt.Printf("类型是：%T \n 值是：%v", p.Result[0]["attributes"], p.Result[0]["attributes"])
>>
类型是：[]interface {} // 因为你写的 Result 是 [] interface{}，对于对象数组切片等，要想拿到值，就要断言转类型，普通的字符串都是可以直接取出用的
值是：[map[name:正常 score:9.578981399536133 value:0]]
还有其他的问题，用到了在看吧