Go语言中将任意数据结构转换为字节切片或字符串的通用方法

package main

import (
    "bytes"
    "encoding/gob"
    "fmt"
    "log"
)

// User 定义一个示例结构体
type User struct {
    ID   int
    Name string
    Email string // 必须是导出字段（首字母大写）
    IsActive bool
}

func main() {
    user := User{
        ID:       1,
        Name:     "Alice",
        Email:    "alice@example.com",
        IsActive: true,
    }

    // 1. 创建一个 bytes.Buffer 用于存储编码后的数据
    var buffer bytes.Buffer

    // 2. 创建一个 gob.Encoder，将数据写入 buffer
    encoder := gob.NewEncoder(&buffer)

    // 3. 编码结构体
    err := encoder.Encode(user)
    if err != nil {
        log.Fatalf("gob 编码失败: %v", err)
    }

    // 编码后的字节切片
    encodedBytes := buffer.Bytes()
    fmt.Printf("原始结构体: %+v\n", user)
    fmt.Printf("编码后的字节切片长度: %d 字节\n", len(encodedBytes))
    fmt.Printf("编码后的字节切片: %x\n", encodedBytes) // 以十六进制打印
}

package main

import (
    "bytes"
    "encoding/gob"
    "fmt"
    "log"
)

// User 定义一个示例结构体，与编码时保持一致
type User struct {
    ID   int
    Name string
    Email string
    IsActive bool
}

func main() {
    // 假设这是从 Memcache 或其他地方读取到的编码数据
    // 这里我们直接使用上一个示例中编码后的数据
    user := User{
        ID:       1,
        Name:     "Alice",
        Email:    "alice@example.com",
        IsActive: true,
    }
    var buffer bytes.Buffer
    encoder := gob.NewEncoder(&buffer)
    err := encoder.Encode(user)
    if err != nil {
        log.Fatalf("gob 编码失败: %v", err)
    }
    encodedBytes := buffer.Bytes()

    // 1. 创建一个 bytes.Reader 从字节切片读取数据
    reader := bytes.NewReader(encodedBytes)

    // 2. 创建一个 gob.Decoder，从 reader 读取数据
    decoder := gob.NewDecoder(reader)

    // 3. 创建一个目标结构体变量用于接收解码后的数据
    var decodedUser User

    // 4. 解码数据到目标结构体
    err = decoder.Decode(&decodedUser) // 注意这里需要传入指针
    if err != nil {
        log.Fatalf("gob 解码失败: %v", err)
    }

    fmt.Printf("解码后的结构体: %+v\n", decodedUser)
    fmt.Printf("原始数据与解码数据是否一致: %t\n", decodedUser == user) // 简单比较
}

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

// Product 定义一个示例结构体
type Product struct {
    ProductID   string `json:"product_id"` // JSON Tag 可以自定义字段名
    ProductName string `json:"product_name"`
    Price       float64 `json:"price"`
    InStock     bool    `json:"in_stock"`
    // 未导出的字段（首字母小写）不会被 JSON 编码
    internalCode string 
}

func main() {
    product := Product{
        ProductID:    "P001",
        ProductName:  "Go Programming Book",
        Price:        49.99,
        InStock:      true,
        internalCode: "secret", // 此字段不会被编码
    }

    // 1. 使用 json.Marshal 编码结构体为字节切片
    jsonData, err := json.Marshal(product)
    if err != nil {
        log.Fatalf("JSON 编码失败: %v", err)
    }

    fmt.Printf("原始结构体: %+v\n", product)
    fmt.Printf("编码后的 JSON 字符串: %s\n", jsonData) // jsonData 是 []byte，直接打印会转换为字符串
}

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

// Product 定义一个示例结构体，与编码时保持一致
type Product struct {
    ProductID   string `json:"product_id"`
    ProductName string `json:"product_name"`
    Price       float64 `json:"price"`
    InStock     bool    `json:"in_stock"`
}

func main() {
    // 假设这是从外部系统或 Memcache 读取到的 JSON 字符串
    jsonString := `{"product_id":"P002","product_name":"Go Mug","price":15.00,"in_stock":true}`
    jsonData := []byte(jsonString)

    // 1. 创建一个目标结构体变量用于接收解码后的数据
    var decodedProduct Product

    // 2. 使用 json.Unmarshal 解码字节切片到目标结构体
    err := json.Unmarshal(jsonData, &decodedProduct) // 注意这里需要传入指针
    if err != nil {
        log.Fatalf("JSON 解码失败: %v", err)
    }

    fmt.Printf("解码后的结构体: %+v\n", decodedProduct)
}