package zlib

import "compress/zlib"

zlib 包实现了 zlib 格式压缩数据的读写, 该格式由 RFC 1950 规定。

该实现提供了在读取时解压、在写入时压缩的过滤器。 例如,将压缩数据写入缓冲区:

var b bytes.Buffer
w := zlib.NewWriter(&b)
w.Write([]byte("hello, world\n"))
w.Close()

以及将这些数据读回:

r, err := zlib.NewReader(&b)
io.Copy(os.Stdout, r)
r.Close()

Index

Examples

Constants

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

这些常量复制自 flate 包,因此导入 compress/zlib 的代码 无需再导入 compress/flate。

Variables

var (
	// ErrChecksum 在读取校验和无效的 ZLIB 数据时返回。
	ErrChecksum = errors.New("zlib: invalid checksum")
	// ErrDictionary 在读取字典无效的 ZLIB 数据时返回。
	ErrDictionary = errors.New("zlib: invalid dictionary")
	// ErrHeader 在读取头部无效的 ZLIB 数据时返回。
	ErrHeader = errors.New("zlib: invalid header")
)

Functions

func NewReader

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

NewReader 创建一个新的 ReadCloser。 从返回的 ReadCloser 读取时会从 r 读取并解压数据。 如果 r 未实现 io.ByteReader,解压器可能从 r 读取比所需更多的数据。 调用者有责任在完成后对 ReadCloser 调用 Close。

NewReader 返回的 io.ReadCloser 也实现了 Resetter。

Example
package main

import (
	"bytes"
	"compress/zlib"
	"io"
	"os"
)

func main() {
	buff := []byte{120, 156, 202, 72, 205, 201, 201, 215, 81, 40, 207,
		47, 202, 73, 225, 2, 4, 0, 0, 255, 255, 33, 231, 4, 147}
	b := bytes.NewReader(buff)

	r, err := zlib.NewReader(b)
	if err != nil {
		panic(err)
	}
	io.Copy(os.Stdout, r)

	r.Close()
}

Output:

hello, world

func NewReaderDict

func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, error)

NewReaderDict 类似于 NewReader,但使用预设字典。 如果压缩数据没有引用该字典,NewReaderDict 会忽略它。 如果压缩数据引用了不同的字典,NewReaderDict 返回 ErrDictionary。

NewReaderDict 返回的 ReadCloser 也实现了 Resetter。

Types

type Resetter

type Resetter interface {
	// Reset 丢弃任何已缓冲的数据,并把 Resetter 重置为
	// 如同刚用给定 reader 初始化的状态。
	Reset(r io.Reader, dict []byte) error
}

Resetter 重置由 NewReader 或 NewReaderDict 返回的 ReadCloser, 以切换到新的底层 Reader。这允许复用 ReadCloser 而不是分配一个新的。

type Writer

type Writer struct {
	// contains filtered or unexported fields
}

Writer 接收写入其中的数据,并将该数据的压缩形式 写入底层 writer(参见 NewWriter)。

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

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

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

Example
package main

import (
	"bytes"
	"compress/zlib"
	"fmt"
)

func main() {
	var b bytes.Buffer

	w := zlib.NewWriter(&b)
	w.Write([]byte("hello, world\n"))
	w.Close()
	fmt.Println(b.Bytes())
}

Output:

[120 156 202 72 205 201 201 215 81 40 207 47 202 73 225 2 4 0 0 255 255 33 231 4 147]
func NewWriterLevel
func NewWriterLevel(w io.Writer, level int) (*Writer, error)

NewWriterLevel 与 NewWriter 类似,但会指定压缩级别, 而不是假定为 DefaultCompression。

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

func NewWriterLevelDict
func NewWriterLevelDict(w io.Writer, level int, dict []byte) (*Writer, error)

NewWriterLevelDict 与 NewWriterLevel 类似,但会指定用于压缩的字典。

字典可以为 nil。如果不为 nil,在 Writer 关闭之前不应修改其内容。

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

Close 关闭 Writer,将任何未写入的数据刷新到底层 io.Writer, 但不会关闭底层的 io.Writer。

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

Flush 将 Writer 刷新到底层 io.Writer。

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

Reset 清除 Writer z 的状态,使其等同于来自 NewWriterLevel 或 NewWriterLevelDict 的初始状态,但改为写入 w。

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

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