json序列化和反序列化

序列化

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
}



func testStruct() {
    //示範
    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進行序列化
func testMap() {
    //定義一個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))

}

//示範對切片進行序列化, 我們這個切片 []map[string]interface{}
func testSlice() {
    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))
    
}

//對基本資料類型序列化，對基本資料類型進行序列化意義不大
func testFloat64() {
    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))
}

func main() {
    //示範将結構體, map , 切片進行序列号
    testStruct()
    testMap()
    testSlice()//示範對切片的序列化
    testFloat64()//示範對基本資料類型的序列化
}      

monster序列化後={"monster_name":"牛魔王","monster_age":500,"Birthday":"2011-11-11","Sal":8000,"Skill":"牛魔拳"}
a map 序列化後={"address":"洪崖洞","age":30,"name":"紅孩兒"}
slice 序列化後=[{"address":"北京","age":"7","name":"jack"},{"address":["墨西哥","夏威夷"],"age":"20","name":"tom"}]
num1 序列化後=2345.67      

package main
import (
    "fmt"
    "encoding/json"
)

//定義一個結構體
type Monster struct {
    Name string  
    Age int 
    Birthday string //....
    Sal float64
    Skill string
}


//示範将json字元串，反序列化成struct
func unmarshalStruct() {
    //說明str 在項目開發中，是通過網絡傳輸擷取到.. 或者是讀取檔案擷取到
    str := "{\"Name\":\"牛魔王~~~\",\"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 testMap() 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)

}

//示範将json字元串，反序列化成map
func unmarshalMap() {
    //str := "{\"address\":\"洪崖洞\",\"age\":30,\"name\":\"紅孩兒\"}"
    str := testMap()
    //定義一個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)

}

//示範将json字元串，反序列化成切片
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() {

    unmarshalStruct()
    unmarshalMap()
    unmarshalSlice()
}      

反序列化後 monster={牛魔王~~~ 500 2011-11-11 8000 牛魔拳} monster.Name=牛魔王~~~ 
反序列化後 a=map[address:洪崖洞 age:30 name:紅孩兒~~~~~~]
反序列化後 slice=[map[address:北京 age:7 name:jack] map[address:[墨西哥 夏威夷] age:20 name:tom]]