Maison >développement back-end >Golang >Comment sérialiser les types personnalisés lors de l'utilisation de Golang ?

Comment sérialiser les types personnalisés lors de l'utilisation de Golang ?

WBOY
WBOYoriginal
2024-06-03 17:07:00854parcourir

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.

使用 Golang 时如何对自定义类型进行序列化?

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 包中的 GobEncoderGobDecoder 接口。
  • GobEncode 方法接收自定义类型的值并将其写入一个缓冲区。
  • GobDecode
Utilisez la sérialisation JSON

  • Implémentez l'interface json.Marshaler et implémentez la méthode MarshalJSON.

  • La méthode 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🎜🎜
    • Implémenter GobEncoderdans le package encoding/gob > et l'interface GobDecoder. 🎜
    • La méthode 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🎜🎜rrreee
  • Ce 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!

    Déclaration:
    Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn