Maison >développement back-end >Golang >Comment sérialiser les types personnalisés lors de l'utilisation de Golang ?
Dans Go, les méthodes de sérialisation des types personnalisés sont : l'implémentation de l'interface json.Marshaler lors de l'utilisation de la sérialisation JSON et l'implémentation des interfaces GobEncoder et GobDecoder dans le package encoding/gob lors de l'utilisation de la sérialisation Gob.
Sérialiser les types personnalisés à l'aide de Golang
Dans Golang, la sérialisation fait référence à la conversion de l'état d'un objet dans un format qui peut être stocké ou transmis. Pour les types personnalisés, vous devez implémenter l'interface de sérialisation dans le package encoding/json
ou encoding/gob
. encoding/json
或者 encoding/gob
包中的序列化接口。
使用 JSON 序列化
json.Marshaler
接口,实现 MarshalJSON
方法。MarshalJSON
方法接收自定义类型的值并返回其 JSON 表示。实战案例:序列号员工结构体
package main import ( "encoding/json" "fmt" ) // Employee is a custom type representing an employee. type Employee struct { Name string Age int Skills []string } // MarshalJSON implements the json.Marshaler interface. func (e Employee) MarshalJSON() ([]byte, error) { type Alias Employee return json.Marshal(&struct{ Alias }{e}) } func main() { emp := Employee{Name: "John Doe", Age: 30, Skills: []string{"golang", "javascript"}} encoded, err := json.Marshal(emp) if err != nil { fmt.Println("Error:", err) return } fmt.Println("JSON:", string(encoded)) }
使用 Gob 序列化
encoding/gob
包中的 GobEncoder
和 GobDecoder
接口。GobEncode
方法接收自定义类型的值并将其写入一个缓冲区。GobDecode
json.Marshaler
et implémentez la méthode MarshalJSON
.
MarshalJSON
reçoit une valeur d'un type personnalisé et renvoie sa représentation JSON. 🎜🎜🎜Cas pratique : Structure des employés du numéro de série🎜🎜package main import ( "encoding/gob" "fmt" "io/ioutil" "os" ) // ComplexStruct represents a complex data structure. type ComplexStruct struct { Map map[string]int Slice []int InnerStruct struct { Field1 string Field2 int } } func main() { // Register the ComplexStruct type for serialization. gob.Register(ComplexStruct{}) // Create a ComplexStruct instance. cs := ComplexStruct{ Map: map[string]int{"key1": 1, "key2": 2}, Slice: []int{3, 4, 5}, InnerStruct: struct { Field1 string Field2 int }{"value1", 6}, } // Encode the ComplexStruct to a file. f, err := os.Create("data.gob") if err != nil { fmt.Println("Error creating file:", err) return } defer f.Close() enc := gob.NewEncoder(f) if err := enc.Encode(cs); err != nil { fmt.Println("Error encoding:", err) return } // Decode the ComplexStruct from the file. data, err := ioutil.ReadFile("data.gob") if err != nil { fmt.Println("Error reading file:", err) return } dec := gob.NewDecoder(bytes.NewReader(data)) var decoded ComplexStruct if err := dec.Decode(&decoded); err != nil { fmt.Println("Error decoding:", err) return } // Print the decoded struct. fmt.Println("Decoded:", decoded) }🎜🎜Utilisation de la sérialisation Gob🎜🎜
GobEncoder
dans le package encoding/gob
> et l'interface GobDecoder
. 🎜GobEncode
reçoit une valeur de type personnalisée et l'écrit dans un tampon. La méthode 🎜GobDecode
lit les données du tampon et restaure la valeur du type personnalisé. 🎜🎜🎜🎜Cas pratique : le numéro de série est une structure complexe🎜🎜rrreeeCe qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!