compress/gzip provides gzip compression and decompression compatible with the gzip file format (RFC 1952). You typically use:

gzip.Writer to compress (write compressed data)

gzip.Reader to decompress (read compressed data)

gzip /ˈdʒiːzɪp/ = định dạng nén gzip

compress /kəmˈpres/ = nén

decompress /ˌdiːkəmˈpres/ = giải nén

compatible /kəmˈpætəbl/ = tương thích

 import "compress/gzip" 

Use compress/gzip when you need to:

Reduce size of text-like data (JSON, HTML, logs) for network transfer or storage

Implement HTTP gzip responses (server-side)

Read/write .gz files

Compress streams (data piped through io.Reader/io.Writer)

transfer /ˈtrænsfɝː/ = truyền tải

storage /ˈstɔːrɪdʒ/ = lưu trữ

stream /striːm/ = luồng dữ liệu

What it is: an io.WriteCloser that compresses anything written to it and forwards compressed bytes to an underlying io.Writer.

What it is for: compressing data (writing gzip output).

Important:

Always call Close() to flush final bytes and write gzip footer.

Optionally call Flush() for streaming scenarios.

footer /ˈfʊtər/ = phần cuối (kết thúc format)

flush /flʌʃ/ = xả/đẩy dữ liệu còn lại ra

Create:

gzip.NewWriter(w io.Writer) *gzip.Writer

gzip.NewWriterLevel(w io.Writer, level int) (*gzip.Writer, error)

Compression levels:

gzip.NoCompression

gzip.BestSpeed

gzip.BestCompression

gzip.DefaultCompression

gzip.HuffmanOnly

level /ˈlevəl/ = mức độ

huffman /ˈhʌfmən/ = (thuật toán) Huffman

What it is: an io.ReadCloser that reads compressed gzip data from an underlying io.Reader and outputs decompressed bytes.

What it is for: decompressing data (reading original content).

Create:

gzip.NewReader(r io.Reader) (*gzip.Reader, error)

Important:

Call Close() when done.

package main
 
import (
"bytes"
"compress/gzip"
)
 
func GzipCompress(data []byte) ([]byte, error) {
var buf bytes.Buffer
 
zw := gzip.NewWriter(&buf)      // create gzip.Writer
if _, err := zw.Write(data); err != nil {
	_ = zw.Close()
	return nil, err
}
if err := zw.Close(); err != nil { // IMPORTANT: finalize gzip stream
	return nil, err
}
 
return buf.Bytes(), nil
 
 
}

Why Close() is required:

Without Close(), the last chunk + gzip metadata may not be written.

package main
 
import (
"bytes"
"compress/gzip"
"io"
)
 
func GzipDecompress(gzData []byte) ([]byte, error) {
zr, err := gzip.NewReader(bytes.NewReader(gzData))
if err != nil {
return nil, err
}
defer zr.Close()
 
return io.ReadAll(zr)
 
 
}

defer /dɪˈfɝː/ = hoãn lại (thường để đóng resource)

Example: compress data as you write to a file/network writer.

zw := gzip.NewWriter(dstWriter)
defer zw.Close()
 
// write to zw, not dstWriter
_, _ = zw.Write(chunk)

zr, _ := gzip.NewReader(srcReader)
defer zr.Close()
 
// read from zr to get decompressed bytes

Already-compressed formats (JPEG/PNG/MP4/PDF) often won’t shrink much.

Very small payloads may grow due to gzip headers.

payload /ˈpeɪloʊd/ = dữ liệu chính (nội dung truyền)

gzip.Writer — write compressed bytes (nén)

gzip.NewWriter(w) — create a compressor targeting w

gzip.NewWriterLevel(w, level) — choose compression level

gzip.Reader — read decompressed bytes (giải nén)

gzip.NewReader® — create a decompressor reading from r

Close() — finalize/flush gzip stream (bắt buộc khi nén)