Go：json（序列化、反序列化）

- 日理万妓 2022-01-06 21:25 346阅读 0赞

## **一、示例** ##

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

package main
    
    import (
        "encoding/json"
        "fmt"
    )
    
    type Person struct {
        Name    string  `json:"name"`
        Age     int     `json:"age"`
        Salary  float64 `json:"salary"`
    }
    
    type Student struct {
        Name    string  `json:"name"`
        Age     int     `json:"age"`
        Salary  float64 `json:"salary"`
    }
    
    // 对数据进行序列化
    func marshalData(data interface{}) []byte{
        data, err := json.Marshal(data)
        if err != nil {
            fmt.Printf("序列化失败：%s\n", err)
        }
        fmt.Printf("序列化结果：%v\n", data)
        fmt.Printf("序列化结果：%s\n", data)
        return data.([]byte)
    }
    
    // 对 struct 进行序列化
    func marshalStruct() []byte {
        person := Person{
            Name: "佩奇",
            Age: 18,
            Salary: 99.99,
        }
        fmt.Printf("原始的数据：%v\n", person)
        return marshalData(person)
    }
    
    // 对 map 进行序列化
    func marshalMap() []byte {
        var m map[string]interface{}
        m = make(map[string]interface{})
        m["name"] = "盲僧"
        m["age"] = 10
        m["hobby"] = [2]string{"篮球", "游泳"}
        fmt.Printf("原始的数据：%v\n", m)
        return marshalData(m)
    }
    
    // 对 map 切片进行序列化
    func marshalSlice() []byte {
        var slice []map[string]interface{}
        m1 := map[string]interface{}{
            "name": "妖姬",
            "age": 20,
        }
        slice = append(slice, m1)
        m2 := map[string]interface{}{
            "name": "德玛",
            "age": 30,
        }
        slice = append(slice, m2)
        fmt.Printf("原始的数据：%v\n", slice)
        return marshalData(slice)
    }
    
    // 反序列化成 struct
    func unmarshalStruct(data []byte) {
        // 定义一个 Student 实例
        var student Student
        err := json.Unmarshal([]byte(data), &student)
        if err != nil {
            fmt.Println(err)
        }
        fmt.Println("反序列化结果：", student)
    }
    
    // 反序列化成 map
    func unmarshalMap(data []byte) {
        // 定义一个 map
        var m map[string]interface{}
        // 注意：反序列化 map，不需要 make，因为 make 操作被封装到了 Unmarsha 函数中
        err := json.Unmarshal([]byte(data), &m)
        if err != nil {
            fmt.Println(err)
        }
        fmt.Println("反序列化结果：", m)
    }
    
    // 反序列化成 slice
    func unmarshalSlice(data []byte) {
        // 定义一个 silce
        var slice []map[string]interface{}
        // 注意：反序列化 slice，不需要 make，因为 make 操作被封装到了 Unmarsha 函数中
        err := json.Unmarshal([]byte(data), &slice)
        if err != nil {
            fmt.Println(err)
        }
        fmt.Println("反序列化结果：", slice)
    }
    
    func main() {
        // 序列化
        result1 := marshalStruct()
        fmt.Println()
        result2 := marshalMap()
        fmt.Println()
        result3 := marshalSlice()
        fmt.Println()
        // 反序列化
        unmarshalStruct(result1)
        unmarshalMap(result2)
        unmarshalSlice(result3)
    }

**![1468833-20190531001035500-426331578.png][]**

## 二、注意！！！ ##

**在反序列化一个 json 字符串时，要确保反序列化后的数据类型和序列化之前的数据类型一致。**

转载于:https://www.cnblogs.com/believepd/p/10952897.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20211227/e7bcaa34fb394f3fa8b0b19cf927fdd4.png
[1468833-20190531001035500-426331578.png]: /images/20211227/e9ce2818eaaf453fb0ac27676233a53e.png