How to serialize custom types when using Golang?

In Go, the methods for serializing custom types are: implementing the json.Marshaler interface when using JSON serialization, and implementing the GobEncoder and GobDecoder interfaces in the encoding/gob package when using Gob serialization.

Use Golang to serialize custom types

In Golang, serialization refers to converting the state of an object into The format in which it can be stored or transmitted. For custom types, you need to implement the serialization interface in the encoding/json or encoding/gob package.

Use JSON serialization

• Implement the json.Marshaler interface and implement the MarshalJSON method.
• MarshalJSON Method receives a value of a custom type and returns its JSON representation.

Practical case: Serial number employee structure

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

Using Gob serialization

• Implementation The GobEncoder and GobDecoder interfaces in the encoding/gob package.
• GobEncode method receives a value of a custom type and writes it to a buffer.
• GobDecode Method reads data from the buffer and restores the value of the custom type.

Practical case: serial number is a complex structure

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

The above is the detailed content of How to serialize custom types when using Golang?. For more information, please follow other related articles on the PHP Chinese website!