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

一、示例

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)
}

二、注意！！！

在反序列化一個 json 字符串時，要確保反序列化后的數據類型和序列化之前的數據類型一致。