go json 序列化操作

参考：
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 string json:"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]]

还有其他的问题，用到了在看吧