Go语言中存储和管理多字节切片的正确姿势

package main

import (
    "bytes"
    "compress/gzip"
    "fmt"
    "io/ioutil" // 用于解压读取
)

// storage 结构体，用于存储压缩后的数据
type storage struct {
    compressed []byte // 意图存储多个压缩后的字节切片
}

// compress 方法，将传入的字节切片进行Gzip压缩并存储
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("写入Gzip失败: %w", err)
    }
    err = w.Close() // 必须关闭writer才能将所有数据写入buf
    if err != nil {
        return fmt.Errorf("关闭Gzip writer失败: %w", err)
    }

    store := buf.Bytes()
    // 错误的做法：将一个 []byte 追加到另一个 []byte
    s.compressed = append(s.compressed, store...) // 注意这里的...，它将store的元素逐个追加
    return nil
}

// 原始代码中append的错误理解：
// s.compressed = append(s.compressed, store)
// 如果compressed是[]byte，而store也是[]byte，Go语言不允许直接将[]byte作为单个元素append到[]byte中。
// 必须使用 `...` 运算符将store展开，将其所有元素追加到s.compressed中。
// 即使使用了 `...`，结果也只是将所有压缩数据连接成一个大的字节切片，
// 而不是存储为独立的多个压缩块。

package main

import (
    "bytes"
    "compress/gzip"
    "fmt"
    "io/ioutil"
)

// CorrectStorage 结构体，用于存储多个独立的压缩字节切片
type CorrectStorage struct {
    compressed [][]byte // 正确的做法：存储一个字节切片的切片
}

// compress 方法，将传入的字节切片进行Gzip压缩并存储
func (s *CorrectStorage) compress(n []byte) error {
    var buf bytes.Buffer
    w := gzip.NewWriter(&buf)
    _, err := w.Write(n)
    if err != nil {
        return fmt.Errorf("写入Gzip失败: %w", err)
    }
    err = w.Close() // 必须关闭writer才能将所有数据写入buf
    if err != nil {
        return fmt.Errorf("关闭Gzip writer失败: %w", err)
    }

    store := buf.Bytes()
    // 正确的做法：将一个 []byte 作为独立元素追加到 [][]byte 中
    s.compressed = append(s.compressed, store)
    return nil
}

package main

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

// CorrectStorage 结构体，用于存储多个独立的压缩字节切片
type CorrectStorage struct {
    compressed [][]byte // 正确的做法：存储一个字节切片的切片
}

// compress 方法，将传入的字节切片进行Gzip压缩并存储
func (s *CorrectStorage) compress(n []byte) error {
    var buf bytes.Buffer
    w := gzip.NewWriter(&buf)

    // 写入数据
    _, err := w.Write(n)
    if err != nil {
        return fmt.Errorf("写入Gzip失败: %w", err)
    }

    // 关闭writer，确保所有数据被写入buf
    err = w.Close() 
    if err != nil {
        return fmt.Errorf("关闭Gzip writer失败: %w", err)
    }

    store := buf.Bytes()
    // 将压缩后的 []byte 作为独立元素追加到 [][]byte 中
    s.compressed = append(s.compressed, store)
    return nil
}

// decompressAndPrint 方法，解压并打印存储的所有字节切片
func (s *CorrectStorage) decompressAndPrint() {
    fmt.Println("\n--- 解压并打印存储的数据 ---")
    if len(s.compressed) == 0 {
        fmt.Println("存储中没有数据。")
        return
    }

    for i, data := range s.compressed {
        // 创建Gzip reader
        r, err := gzip.NewReader(bytes.NewReader(data))
        if err != nil {
            log.Printf("创建Gzip reader失败 (索引 %d): %v", i, err)
            continue
        }
        defer r.Close() // 确保reader被关闭

        // 读取解压后的数据
        decompressedData, err := ioutil.ReadAll(r)
        if err != nil {
            log.Printf("读取解压数据失败 (索引 %d): %v", i, err)
            continue
        }
        fmt.Printf("索引 %d (原始长度: %d, 压缩后长度: %d): %s\n", 
            i, len(data), len(decompressedData), string(decompressedData))
    }
}

func main() {
    myStorage := CorrectStorage{}

    // 压缩并存储第一段数据
    data1 := []byte("Hello, Go Gzip Compression!")
    fmt.Printf("原始数据1: %s (长度: %d)\n", string(data1), len(data1))
    err := myStorage.compress(data1)
    if err != nil {
        log.Fatalf("压缩数据1失败: %v", err)
    }
    fmt.Printf("存储的压缩数据块数量: %d\n", len(myStorage.compressed))
    fmt.Printf("第一个数据块的压缩长度: %d\n", len(myStorage.compressed[0]))


    // 压缩并存储第二段数据
    data2 := []byte("This is another piece of text to be compressed.")
    fmt.Printf("\n原始数据2: %s (长度: %d)\n", string(data2), len(data2))
    err = myStorage.compress(data2)
    if err != nil {
        log.Fatalf("压缩数据2失败: %v", err)
    }
    fmt.Printf("存储的压缩数据块数量: %d\n", len(myStorage.compressed))
    fmt.Printf("第二个数据块的压缩长度: %d\n", len(myStorage.compressed[1]))

    // 压缩并存储第三段数据
    data3 := []byte("A short message.")
    fmt.Printf("\n原始数据3: %s (长度: %d)\n", string(data3), len(data3))
    err = myStorage.compress(data3)
    if err != nil {
        log.Fatalf("压缩数据3失败: %v", err)
    }
    fmt.Printf("存储的压缩数据块数量: %d\n", len(myStorage.compressed))
    fmt.Printf("第三个数据块的压缩长度: %d\n", len(myStorage.compressed[2]))


    // 解压并打印所有存储的数据
    myStorage.decompressAndPrint()
}