Go语言：正确存储和管理多个字节切片（[][]byte）

package main

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

type storage struct {
    compressed []byte // 旨在存储多个压缩后的字节切片
}

func (s *storage) compressAndStore(data []byte) {
    var buf bytes.Buffer
    w := gzip.NewWriter(&buf)
    _, err := w.Write(data)
    if err != nil {
        log.Printf("Error writing to gzip writer: %v", err)
        return
    }
    err = w.Close() // 必须关闭writer以确保所有数据被刷新到buf
    if err != nil {
        log.Printf("Error closing gzip writer: %v", err)
        return
    }

    compressedData := buf.Bytes()
    // 错误的做法：将新的压缩数据追加到现有的 []byte 中
    // 这会将 compressedData 的内容直接拼接到 s.compressed 的末尾
    s.compressed = append(s.compressed, compressedData...) 
    fmt.Printf("Appended %d bytes. Current total compressed size: %d\n", len(compressedData), len(s.compressed))
}

func main() {
    s := &storage{}

    data1 := []byte("Hello, Go language programming!")
    data2 := []byte("This is a second piece of data.")
    data3 := []byte("Another example for demonstration.")

    s.compressAndStore(data1)
    s.compressAndStore(data2)
    s.compressAndStore(data3)

    // 此时 s.compressed 包含了所有压缩数据的拼接，无法区分原始的 data1, data2, data3
    fmt.Printf("Final stored compressed data length: %d\n", len(s.compressed))
}

package main

import (
    "bytes"
    "compress/gzip"
    "fmt"
    "io" // 导入io包以处理解压
    "log"
)

type storage struct {
    compressed [][]byte // 正确的做法：存储多个独立的字节切片
}

func (s *storage) compressAndStore(data []byte) {
    var buf bytes.Buffer
    w := gzip.NewWriter(&buf)
    _, err := w.Write(data)
    if err != nil {
        log.Printf("Error writing to gzip writer: %v", err)
        return
    }
    err = w.Close() // 必须关闭writer以确保所有数据被刷新到buf
    if err != nil {
        log.Printf("Error closing gzip writer: %v", err)
        return
    }

    compressedData := buf.Bytes()
    // 正确的做法：将整个 compressedData 切片作为一个元素追加到 s.compressed 中
    s.compressed = append(s.compressed, compressedData) 
    fmt.Printf("Stored a new compressed block of %d bytes. Total blocks: %d\n", len(compressedData), len(s.compressed))
}

// 可选：添加一个方法来解压并获取存储的数据
func (s *storage) decompressBlock(index int) ([]byte, error) {
    if index < 0 || index >= len(s.compressed) {
        return nil, fmt.Errorf("index out of bounds: %d", index)
    }

    compressedBlock := s.compressed[index]
    reader := bytes.NewReader(compressedBlock)
    gr, err := gzip.NewReader(reader)
    if err != nil {
        return nil, fmt.Errorf("error creating gzip reader: %v", err)
    }
    defer gr.Close()

    decompressedBuf := new(bytes.Buffer)
    _, err = io.Copy(decompressedBuf, gr)
    if err != nil {
        return nil, fmt.Errorf("error decompressing data: %v", err)
    }
    return decompressedBuf.Bytes(), nil
}

func main() {
    s := &storage{}

    data1 := []byte("Hello, Go language programming!")
    data2 := []byte("This is a second piece of data.")
    data3 := []byte("Another example for demonstration.")

    s.compressAndStore(data1)
    s.compressAndStore(data2)
    s.compressAndStore(data3)

    fmt.Printf("\nFinal stored compressed blocks count: %d\n", len(s.compressed))

    // 遍历并解压每个存储的块
    for i := 0; i < len(s.compressed); i++ {
        decompressed, err := s.decompressBlock(i)
        if err != nil {
            log.Printf("Error decompressing block %d: %v", i, err)
            continue
        }
        fmt.Printf("Block %d (decompressed): %s\n", i, string(decompressed))
    }
}