package gzip

import "compress/gzip"

gzip 包实现了 gzip 格式压缩文件的读写, 格式规范见 RFC 1952。

Example (CompressingReader)
package main

import (
	"compress/gzip"
	"io"
	"log"
	"net/http"
	"net/http/httptest"
	"os"
	"strings"
)

func main() {
	// This is an example of writing a compressing reader.
	// This can be useful for an HTTP client body, as shown.

	const testdata = "the data to be compressed"

	// This HTTP handler is just for testing purposes.
	handler := http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
		zr, err := gzip.NewReader(req.Body)
		if err != nil {
			log.Fatal(err)
		}

		// Just output the data for the example.
		if _, err := io.Copy(os.Stdout, zr); err != nil {
			log.Fatal(err)
		}
	})
	ts := httptest.NewServer(handler)
	defer ts.Close()

	// The remainder is the example code.

	// The data we want to compress, as an io.Reader
	dataReader := strings.NewReader(testdata)

	// bodyReader is the body of the HTTP request, as an io.Reader.
	// httpWriter is the body of the HTTP request, as an io.Writer.
	bodyReader, httpWriter := io.Pipe()

	// Make sure that bodyReader is always closed, so that the
	// goroutine below will always exit.
	defer bodyReader.Close()

	// gzipWriter compresses data to httpWriter.
	gzipWriter := gzip.NewWriter(httpWriter)

	// errch collects any errors from the writing goroutine.
	errch := make(chan error, 1)

	go func() {
		defer close(errch)
		sentErr := false
		sendErr := func(err error) {
			if !sentErr {
				errch <- err
				sentErr = true
			}
		}

		// Copy our data to gzipWriter, which compresses it to
		// gzipWriter, which feeds it to bodyReader.
		if _, err := io.Copy(gzipWriter, dataReader); err != nil && err != io.ErrClosedPipe {
			sendErr(err)
		}
		if err := gzipWriter.Close(); err != nil && err != io.ErrClosedPipe {
			sendErr(err)
		}
		if err := httpWriter.Close(); err != nil && err != io.ErrClosedPipe {
			sendErr(err)
		}
	}()

	// Send an HTTP request to the test server.
	req, err := http.NewRequest("PUT", ts.URL, bodyReader)
	if err != nil {
		log.Fatal(err)
	}

	// Note that passing req to http.Client.Do promises that it
	// will close the body, in this case bodyReader.
	resp, err := ts.Client().Do(req)
	if err != nil {
		log.Fatal(err)
	}

	// Check whether there was an error compressing the data.
	if err := <-errch; err != nil {
		log.Fatal(err)
	}

	// For this example we don't care about the response.
	resp.Body.Close()

}

Output:

the data to be compressed
Example (WriterReader)
package main

import (
	"bytes"
	"compress/gzip"
	"fmt"
	"io"
	"log"
	"os"
	"time"
)

func main() {
	var buf bytes.Buffer
	zw := gzip.NewWriter(&buf)

	// Setting the Header fields is optional.
	zw.Name = "a-new-hope.txt"
	zw.Comment = "an epic space opera by George Lucas"
	zw.ModTime = time.Date(1977, time.May, 25, 0, 0, 0, 0, time.UTC)

	_, err := zw.Write([]byte("A long time ago in a galaxy far, far away..."))
	if err != nil {
		log.Fatal(err)
	}

	if err := zw.Close(); err != nil {
		log.Fatal(err)
	}

	zr, err := gzip.NewReader(&buf)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Name: %s\nComment: %s\nModTime: %s\n\n", zr.Name, zr.Comment, zr.ModTime.UTC())

	if _, err := io.Copy(os.Stdout, zr); err != nil {
		log.Fatal(err)
	}

	if err := zr.Close(); err != nil {
		log.Fatal(err)
	}

}

Output:

Name: a-new-hope.txt
Comment: an epic space opera by George Lucas
ModTime: 1977-05-25 00:00:00 +0000 UTC

A long time ago in a galaxy far, far away...

Index

Examples

Constants

const (
	NoCompression      = flate.NoCompression
	BestSpeed          = flate.BestSpeed
	BestCompression    = flate.BestCompression
	DefaultCompression = flate.DefaultCompression
	HuffmanOnly        = flate.HuffmanOnly
)

这些常量复制自 flate 包,这样导入 compress/gzip 的代码 就无需再导入 compress/flate。

Variables

var (
	// 当读取的 GZIP 数据校验和无效时,返回 ErrChecksum。
	ErrChecksum = errors.New("gzip: invalid checksum")
	// 当读取的 GZIP 数据头部无效时,返回 ErrHeader。
	ErrHeader = errors.New("gzip: invalid header")
)

Types

type Header struct {
	Comment string    // 注释
	Extra   []byte    // “额外数据”
	ModTime time.Time // 修改时间
	Name    string    // 文件名
	OS      byte      // 操作系统类型
}

gzip 文件存储一个头部,提供关于压缩文件的元数据。 该头部以 Writer 和 Reader 结构体的字段形式暴露。

由于 GZIP 文件格式的限制,字符串必须采用 UTF-8 编码, 且只能包含 U+0001 到 U+00FF 的 Unicode 码点。

type Reader

type Reader struct {
	Header // 在 NewReader 或 Reader.Reset 之后有效
	// contains filtered or unexported fields
}

Reader 是一个 io.Reader,可以从中读取以获取 gzip 格式压缩文件中的未压缩数据。

一般而言,一个 gzip 文件可以是多个 gzip 文件的拼接, 每个文件都有自己的头部。从 Reader 读取会 返回各文件未压缩数据的拼接。 只有第一个头部会记录在 Reader 字段中。

Gzip 文件存储未压缩数据的长度和校验和。 如果 Reader.Read 到达未压缩数据的末尾时 数据不具有预期的长度或校验和, Reader 将返回 ErrChecksum。客户端应将 Reader.Read 返回的数据视为暂定的,直到收到标志着 数据末尾的 io.EOF。

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

NewReader 创建一个新的 Reader,读取给定的 reader。 如果 r 未同时实现 io.ByteReader, 解压器可能会从 r 读取超出必要的数据。

调用方有责任在使用完毕后调用 Reader.Close。

返回的 Reader 中 Reader.Header 字段将是有效的。

func (*Reader) Close
func (z *Reader) Close() error

Close 关闭 Reader。它不会关闭底层 reader。 为了验证 GZIP 校验和,必须将 reader 完全消费直到 io.EOF。

func (*Reader) Multistream
func (z *Reader) Multistream(ok bool)

Multistream 控制 reader 是否支持多流文件。

如果启用(默认),Reader 期望输入是一系列 各自独立的 gzip 数据流,每个都有自己的头部和 尾部,以 EOF 结束。其效果是,一系列 gzip 文件的拼接被视为等同于 该序列拼接后的 gzip。这是 gzip reader 的标准行为。

调用 Multistream(false) 会禁用此行为;当读取区分 单个 gzip 数据流、或将 gzip 数据流与其他数据流混合的文件格式时, 禁用该行为会很有用。 在此模式下,当 Reader 到达数据流末尾时, Reader.Read 返回 io.EOF。底层 reader 必须实现 io.ByteReader, 以便使其恰好停留在 gzip 流之后。 要开始下一个流,调用 z.Reset(r),然后调用 z.Multistream(false)。 如果没有下一个流,z.Reset(r) 将返回 io.EOF。

Example
package main

import (
	"bytes"
	"compress/gzip"
	"fmt"
	"io"
	"log"
	"os"
	"time"
)

func main() {
	var buf bytes.Buffer
	zw := gzip.NewWriter(&buf)

	var files = []struct {
		name    string
		comment string
		modTime time.Time
		data    string
	}{
		{"file-1.txt", "file-header-1", time.Date(2006, time.February, 1, 3, 4, 5, 0, time.UTC), "Hello Gophers - 1"},
		{"file-2.txt", "file-header-2", time.Date(2007, time.March, 2, 4, 5, 6, 1, time.UTC), "Hello Gophers - 2"},
	}

	for _, file := range files {
		zw.Name = file.name
		zw.Comment = file.comment
		zw.ModTime = file.modTime

		if _, err := zw.Write([]byte(file.data)); err != nil {
			log.Fatal(err)
		}

		if err := zw.Close(); err != nil {
			log.Fatal(err)
		}

		zw.Reset(&buf)
	}

	zr, err := gzip.NewReader(&buf)
	if err != nil {
		log.Fatal(err)
	}

	for {
		zr.Multistream(false)
		fmt.Printf("Name: %s\nComment: %s\nModTime: %s\n\n", zr.Name, zr.Comment, zr.ModTime.UTC())

		if _, err := io.Copy(os.Stdout, zr); err != nil {
			log.Fatal(err)
		}

		fmt.Print("\n\n")

		err = zr.Reset(&buf)
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
	}

	if err := zr.Close(); err != nil {
		log.Fatal(err)
	}

}

Output:

Name: file-1.txt
Comment: file-header-1
ModTime: 2006-02-01 03:04:05 +0000 UTC

Hello Gophers - 1

Name: file-2.txt
Comment: file-header-2
ModTime: 2007-03-02 04:05:06 +0000 UTC

Hello Gophers - 2
func (*Reader) Read
func (z *Reader) Read(p []byte) (n int, err error)

Read 实现 io.Reader,从其底层 reader 读取未压缩字节。

func (*Reader) Reset
func (z *Reader) Reset(r io.Reader) error

Reset 丢弃 Reader z 的状态,使其等同于 从 NewReader 得到的初始状态,但改为从 r 读取。 这样可以复用 Reader,而不必分配一个新的。

type Writer

type Writer struct {
	Header // 在首次调用 Write、Flush 或 Close 时写入
	// contains filtered or unexported fields
}

Writer 是一个 io.WriteCloser。 写入 Writer 的数据会被压缩并写入 w。

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

NewWriter 返回一个新的 Writer。 写入所返回 writer 的数据会被压缩并写入 w。

调用者有责任在使用完毕后调用 Writer 的 Close。 写入的数据可能会被缓冲,直到 Close 时才刷新。

希望设置 Writer.Header 中字段的调用者,必须在首次调用 Write、Flush 或 Close 之前完成设置。

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

NewWriterLevel 类似 NewWriter,但指定压缩级别,而不是假定使用 DefaultCompression。

压缩级别可以是 DefaultCompression、NoCompression、HuffmanOnly, 或者是 BestSpeed 与 BestCompression 之间(含两端)的任意整数值。 如果级别有效,则返回的错误为 nil。

func (*Writer) Close
func (z *Writer) Close() error

Close 通过将所有未写入的数据刷新到底层 io.Writer 并写入 GZIP 尾部, 从而关闭 Writer。 它不会关闭底层的 io.Writer。

func (*Writer) Flush
func (z *Writer) Flush() error

Flush 将所有待处理的压缩数据刷新到底层 writer。

它主要用于压缩网络协议,以确保远程读取方有足够的数据来重建数据包。 Flush 在数据写入完成之前不会返回。如果底层 writer 返回错误,Flush 会返回该错误。

在 zlib 库的术语中,Flush 等价于 Z_SYNC_FLUSH。

func (*Writer) Reset
func (z *Writer) Reset(w io.Writer)

Reset 丢弃 Writer z 的状态,使其等同于其原始状态(来自 NewWriter 或 NewWriterLevel)的结果,但改为写入 w。这样可以复用 Writer, 而不必分配一个新的。

func (*Writer) Write
func (z *Writer) Write(p []byte) (int, error)

Write 将 p 的压缩形式写入底层 io.Writer。压缩后的字节在 Writer 关闭之前不一定被刷新。