Home > Article > Backend Development > Introduction to Golang serialization and deserialization
The following column will introduce Golang serialization and deserialization to you in the golang tutorial column. I hope it will be helpful to friends in need!
Our data objects need to be encoded and decoded if they are to be transmitted over the network or saved to a file. Actions, there are currently many encoding formats: json, XML, Gob, Google Protocol Buffer, etc. Of course, the Go language also supports all these encoding formats.
Serialization (Serialization) is the process of converting the state information of an object into a form that can be stored or transmitted. During serialization, an object writes its current state to temporary or persistent storage. By reading the object's state from the storage area and re-creating the object, it is deserialized
Go type json type
bool booleans
float64 booleans
float64 numbers
string strings
nil null
Deserialization
package main
import ( "encoding/json"
"fmt")
type People struct {
name string `json:"name"` // name,小写不导出
Age int `json:"age"` // age
Gender string `json:"gender"` // gender Lesson
}
type Lesson struct {
Lessons []string `json:"lessons"`
}
func main() {
jsonstr := `{"Age": 18,"name": "Jim" ,"gender": "男","lessons":["English","History"],"Room":201,"n":null,"b":false}` // 反序列化 var people People if err := json.Unmarshal([]byte(jsonstr),&people); err == nil { fmt.Println("struct people:") fmt.Println(people)
} // 反序列化 json 字符串中的一部分 var lessons Lesson if err := json.Unmarshal([]byte(jsonstr),&lessons); err == nil { fmt.Println("struct lesson:") fmt.Println(lessons)
} // 反序列化 json 字符串数组
jsonstr = `["English","History"]`
var str []string
if err := json.Unmarshal([]byte(jsonstr), &str); err == nil { fmt.Println("struct str:") fmt.Println(str)
}
}// 打印结果 struct people:
{ 18 男 {[English History]}}
struct lesson:
{[English History]}
struct str:
[English History]
Serialization
package main
import ( "encoding/json"
"fmt")
type People struct {
name string `json:"name"` // name,小写不导出
Age int `json:"age"` // age,在 json 字符串中叫 age
Gender string `json:"gender"` // gender Lesson
}
type Lesson struct {
Lessons []string `json:"lessons"`
}
func main() {
lesson := Lesson{[]string{"Math","English","Chinese"}}
people := &People{
name: "amy",
Age: 22,
Gender: "female",
Lesson: lesson,
} if b, err := json.Marshal(people); err != nil { fmt.Println("Marshal failed...")
}else { fmt.Println(b) fmt.Println(string(b))
}
} // 打印结果
[123 34 97 103 101 34 58 50 50 44 34 103 101 110 100 101 114 34 58 34 102 101 109 97 108 101 34 44 34 108 101 115 115 111 110 115 34 58 91 34 77 97 116 104 34 44 34 69 110 103 108 105 115 104 34 44 34 67 104 105 110 101 115 101 34 93 125]
{"age":22,"gender":"female","lessons["Math","English","Chinese“}
Serialization-->Transfer-->Deserialization
package main
import ( "fmt"
"encoding/json")
type Student struct {
Name string
Age int
Guake bool
Classes []string
Price float32
}
func (s * Student)ShowStu() { fmt.Println("show Student :") fmt.Println("\tName\t:", s.Name) fmt.Println("\tAge\t:", s.Age) fmt.Println("\tGuake\t:", s.Guake) fmt.Println("\tPrice\t:", s.Price) fmt.Printf("\tClasses\t: ") for _, a := range s.Classes { fmt.Printf("%s ", a)
} fmt.Println("")
}
func main() {
st := &Student { "Xiao Ming", 16, true,
[]string{"Math", "English", "Chinese"}, 9.99,
} fmt.Println("before JSON encoding :")
st.ShowStu()
b, err := json.Marshal(st) if err != nil { fmt.Println("encoding faild")
} else { fmt.Println("encoded data : ") fmt.Println(b) fmt.Println(string(b))
}
ch := make(chan string, 1)
go func(c chan string, str string){
c <- str
}(ch, string(b))
strData := <-ch fmt.Println("--------------------------------")
stb := &Student{}
stb.ShowStu()
err = json.Unmarshal([]byte(strData), &stb) if err != nil { fmt.Println("Unmarshal faild")
} else { fmt.Println("Unmarshal success")
stb.ShowStu()
}
}
json data encoding and decoding
The json package provides Decoder and Encoder types to support common json data stream reading and writing . The NewDecoder and NewEncoder functions encapsulate the io.Reader and io.Writer interfaces respectively.
package main
import ( "encoding/json"
"fmt"
"os"
"strings")
type People struct {
name string `json:"name"` // name,小写不导出
Age int `json:"age"` // age,在 json 字符串中叫 age
Gender string `json:"gender"` // gender Lesson
}
type Lesson struct {
Lessons []string `json:"lessons"`
}
func main() {
jsonStr := `{"Age": 18,"name": "Jim" ,"gender": "男","lessons":["English","History"],"Room":201,"n":null,"b":false}`
strR := strings.NewReader(jsonStr)
people := &People{} // 用 NewDecoder && Decode 进行解码给定义好的结构体对象 people
err := json.NewDecoder(strR).Decode(people) if err != nil { fmt.Println(err)
} fmt.Printf("%+v",people) //
// 用 NewEncoder && Encode 把保存的 people 结构体对象编码为 json 保存到文件
f, err := os.Create("./people.json")
json.NewEncoder(f).Encode(people)
}
package main
import (
"encoding/json"
"fmt"
"os"
"strings"
)
type People struct {
name string `json:"name"` // name,小写不导出
Age int `json:"age"` // age,在 json 字符串中叫 age
Gender string `json:"gender"` // gender
Lesson
}
type Lesson struct {
Lessons []string `json:"lessons"`
}
func main() {
jsonStr := `{"Age": 18,"name": "Jim" ,"gender": "男","lessons":["English","History"],"Room":201,"n":null,"b":false}`
strR := strings.NewReader(jsonStr)
people := &People{}
// 用 NewDecoder && Decode 进行解码给定义好的结构体对象 people
err := json.NewDecoder(strR).Decode(people)
if err != nil {
fmt.Println(err)
}
fmt.Printf("%+v",people) //
// 用 NewEncoder && Encode 把保存的 people 结构体对象编码为 json 保存到文件
f, err := os.Create("./people.json")
json.NewEncoder(f).Encode(people)
}
示例
The above is the detailed content of Introduction to Golang serialization and deserialization. For more information, please follow other related articles on the PHP Chinese website!