在Go語言中，數據序列化和反序列化是將數據結構轉換為字節流以便存儲或傳輸，以及從字節流恢復數據結構的過程。Go語言提供了多種方法來實現這些操作。以下是一些常用的序列化和反序列化方法：

序列化方法

1. JSON序列化：

   • 使用encoding/json包可以將Go語言的數據結構轉換為JSON格式的字節流。

   import (
       "encoding/json"
       "fmt"
   )
   
   type Person struct {
       Name string `json:"name"`
       Age  int    `json:"age"`
   }
   
   func main() {
       p := Person{Name: "Alice", Age: 30}
       jsonData, err := json.Marshal(p)
       if err != nil {
           fmt.Println("Error marshaling JSON:", err)
           return
       }
       fmt.Println("JSON data:", string(jsonData))
   }
   

2. XML序列化：

   • 使用encoding/xml包可以將Go語言的數據結構轉換為XML格式的字節流。

   import (
       "encoding/xml"
       "fmt"
   )
   
   type Person struct {
       XMLName xml.Name `xml:"person"`
       Name    string   `xml:"name"`
       Age     int      `xml:"age"`
   }
   
   func main() {
       p := Person{Name: "Alice", Age: 30}
       xmlData, err := xml.MarshalIndent(p, "", "  ")
       if err != nil {
           fmt.Println("Error marshaling XML:", err)
           return
       }
       fmt.Println("XML data:", string(xmlData))
   }
   

3. 二進制序列化：

   • 使用encoding/binary包可以將Go語言的數據結構轉換為二進制格式的字節流。

   import (
       "encoding/binary"
       "fmt"
   )
   
   type Person struct {
       NameLength uint8
       Name       [100]byte
       Age        uint8
   }
   
   func main() {
       p := Person{NameLength: 5, Name: [100]byte{'A', 'l', 'i', 'c', 'e'}, Age: 30}
       var buf bytes.Buffer
       binary.Write(&buf, binary.LittleEndian, p)
       binaryData := buf.Bytes()
       fmt.Println("Binary data:", binaryData)
   }
   

反序列化方法

1. JSON反序列化：

   • 使用encoding/json包可以將JSON格式的字節流轉換回Go語言的數據結構。

   import (
       "encoding/json"
       "fmt"
   )
   
   type Person struct {
       Name string `json:"name"`
       Age  int    `json:"age"`
   }
   
   func main() {
       jsonData := []byte(`{"name":"Bob","age":25}`)
       var p Person
       err := json.Unmarshal(jsonData, &p)
       if err != nil {
           fmt.Println("Error unmarshaling JSON:", err)
           return
       }
       fmt.Println("Deserialized person:", p)
   }
   

2. XML反序列化：

   • 使用encoding/xml包可以將XML格式的字節流轉換回Go語言的數據結構。

   import (
       "encoding/xml"
       "fmt"
   )
   
   type Person struct {
       XMLName xml.Name `xml:"person"`
       Name    string   `xml:"name"`
       Age     int      `xml:"age"`
   }
   
   func main() {
       xmlData := []byte(`<person><name>Bob</name><age>25</age></person>`)
       var p Person
       err := xml.Unmarshal(xmlData, &p)
       if err != nil {
           fmt.Println("Error unmarshaling XML:", err)
           return
       }
       fmt.Println("Deserialized person:", p)
   }
   

3. 二進制反序列化：

   • 使用encoding/binary包可以將二進制格式的字節流轉換回Go語言的數據結構。

   import (
       "encoding/binary"
       "fmt"
   )
   
   type Person struct {
       NameLength uint8
       Name       [100]byte
       Age        uint8
   }
   
   func main() {
       binaryData := []byte{5, 'A', 'l', 'i', 'c', 'e', 0, 0, 0, 30}
       var p Person
       buf := bytes.NewReader(binaryData)
       binary.Read(buf, binary.LittleEndian, &p)
       fmt.Println("Deserialized person:", p)
   }
   

除了上述方法，還有一些第三方庫提供了更多的序列化和反序列化功能，例如protobuf用于高效的二進制序列化，msgpack用于更緊湊的二進制序列化等。選擇哪種方法取決于具體的應用場景和性能需求。