Go语言中存储多个字节切片：[][]byte 的正确使用姿势

package main

import (
    "bytes"
    "compress/gzip"
    "fmt"
    "log"
)

// storage 结构体试图用 []byte 来存储多个压缩结果
type storage struct {
    compressed []byte // 错误：这只能存储一个连续的字节序列
}

// compress 方法旨在压缩输入数据并存储
func (s *storage) compress(n []byte) error {
    var buf bytes.Buffer
    w := gzip.NewWriter(&buf)
    _, err := w.Write(n)
    if err != nil {
        return fmt.Errorf("写入压缩数据失败: %w", err)
    }
    err = w.Close() // 必须关闭writer才能将所有数据写入buffer
    if err != nil {
        return fmt.Errorf("关闭gzip writer失败: %w", err)
    }

    store := buf.Bytes()
    // 这里的 append 操作会将 store (一个 []byte) 的内容追加到 s.compressed (也是一个 []byte) 的末尾
    // 结果是所有压缩数据被串联成一个大的字节切片，失去了独立性。
    s.compressed = append(s.compressed, store...) // 注意这里的 '...'，它将 store 的元素展开追加
    return nil
}

func main() {
    myStorage := &storage{}
    data1 := []byte("Hello, Go language!")
    data2 := []byte("Another piece of data.")

    if err := myStorage.compress(data1); err != nil {
        log.Fatal(err)
    }
    if err := myStorage.compress(data2); err != nil {
        log.Fatal(err)
    }

    // 此时，myStorage.compressed 包含了 data1 和 data2 压缩后的字节串联在一起的结果
    // 无法轻易地将它们作为两个独立的压缩块进行解压。
    fmt.Printf("存储的字节总长度: %d\n", len(myStorage.compressed))
    // 尝试解压会失败，因为 compressed 并非一个有效的 gzip 存档。
    // fmt.Println(DecompressSlice(myStorage.compressed)) // 这将失败
}

// DecompressSlice (辅助函数，用于解压，此处不详细展开，但用于说明问题)
func DecompressSlice(compressed []byte) ([]byte, error) {
    // ... 解压逻辑
    return nil, fmt.Errorf("无法解压串联数据")
}

package main

import (
    "bytes"
    "compress/gzip"
    "fmt"
    "log"
)

// Storage 结构体用于存储多个独立的字节切片
type Storage struct {
    CompressedData [][]byte // 正确：存储多个独立的字节切片
}

// CompressAndStore 方法用于压缩输入字节并将其作为一个独立的切片存储
func (s *Storage) CompressAndStore(data []byte) error {
    var buf bytes.Buffer
    zw := gzip.NewWriter(&buf)
    _, err := zw.Write(data)
    if err != nil {
        return fmt.Errorf("写入压缩数据失败: %w", err)
    }
    err = zw.Close() // 必须关闭writer才能将所有数据写入buffer
    if err != nil {
        return fmt.Errorf("关闭gzip writer失败: %w", err)
    }

    compressedSlice := buf.Bytes()
    // 这里的 append 操作会将 compressedSlice (一个 []byte) 作为一个整体元素追加到 s.CompressedData (一个 [][]byte) 中
    s.CompressedData = append(s.CompressedData, compressedSlice)
    return nil
}

// GetStoredSlice 方法用于获取指定索引的存储切片
func (s *Storage) GetStoredSlice(index int) ([]byte, error) {
    if index < 0 || index >= len(s.CompressedData) {
        return nil, fmt.Errorf("索引超出范围: %d", index)
    }
    return s.CompressedData[index], nil
}

// DecompressSlice 方法用于解压一个字节切片
func DecompressSlice(compressed []byte) ([]byte, error) {
    zr, err := gzip.NewReader(bytes.NewReader(compressed))
    if err != nil {
        return nil, fmt.Errorf("创建gzip reader失败: %w", err)
    }
    defer zr.Close() // 确保关闭 reader

    var decompressedBuf bytes.Buffer
    _, err = decompressedBuf.ReadFrom(zr)
    if err != nil {
        return nil, fmt.Errorf("读取解压数据失败: %w", err)
    }
    return decompressedBuf.Bytes(), nil
}

func main() {
    myStorage := &Storage{}

    // 示例数据
    data1 := []byte("Hello, Go language programming!")
    data2 := []byte("This is another piece of data to be compressed.")
    data3 := []byte("A short message.")

    // 存储第一个数据
    if err := myStorage.CompressAndStore(data1); err != nil {
        log.Fatalf("存储数据1失败: %v", err)
    }
    fmt.Printf("存储了第一个数据，压缩后大小: %d\n", len(myStorage.CompressedData[0]))

    // 存储第二个数据
    if err := myStorage.CompressAndStore(data2); err != nil {
        log.Fatalf("存储数据2失败: %v", err)
    }
    fmt.Printf("存储了第二个数据，压缩后大小: %d\n", len(myStorage.CompressedData[1]))

    // 存储第三个数据
    if err := myStorage.CompressAndStore(data3); err != nil {
        log.Fatalf("存储数据3失败: %v", err)
    }
    fmt.Printf("存储了第三个数据，压缩后大小: %d\n", len(myStorage.CompressedData[2]))

    fmt.Printf("\n总共存储了 %d 个独立的压缩数据块。\n", len(myStorage.CompressedData))

    // 检索并解压第一个数据
    retrieved1, err := myStorage.GetStoredSlice(0)
    if err != nil {
        log.Fatalf("获取第一个数据失败: %v", err)
    }
    decompressed1, err := DecompressSlice(retrieved1)
    if err != nil {
        log.Fatalf("解压第一个数据失败: %v", err)
    }
    fmt.Printf("\n检索并解压第一个数据: %s\n", string(decompressed1))

    // 检索并解压第二个数据
    retrieved2, err := myStorage.GetStoredSlice(1)
    if err != nil {
        log.Fatalf("获取第二个数据失败: %v", err)
    }
    decompressed2, err := DecompressSlice(retrieved2)
    if err != nil {
        log.Fatalf("解压第二个数据失败: %v", err)
    }
    fmt.Printf("检索并解压第二个数据: %s\n", string(decompressed2))

    // 检索并解压第三个数据
    retrieved3, err := myStorage.GetStoredSlice(2)
    if err != nil {
        log.Fatalf("获取第三个数据失败: %v", err)
    }
    decompressed3, err := DecompressSlice(retrieved3)
    if err != nil {
        log.Fatalf("解压第三个数据失败: %v", err)
    }
    fmt.Printf("检索并解压第三个数据: %s\n", string(decompressed3))

    // 尝试获取不存在的索引
    _, err = myStorage.GetStoredSlice(99)
    if err != nil {
        fmt.Printf("\n尝试获取不存在的索引（预期错误）: %v\n", err)
    }
}