©
このドキュメントでは、 php中国語ネットマニュアル リリース
import "compress/flate"
概述
参数
示例
Package flate 实现了 RFC 1951 中描述的 DEFLATE 压缩数据格式. gzip 和 zlib 包实现了对基于 DEFLATE 的文件格式的访问。
预设词典可用于提高压缩比。使用字典的缺点是压缩器和解压缩器必须事先同意使用什么字典。
package mainimport ("bytes""compress/flate""fmt""io""log""os""strings")func main() {// 字典是一串字节。 压缩一些输入数据时，// 压缩器将尝试用找到的匹配替换子串// 在库里。因此，库应该只包含子字符串// 预计会在实际的数据流中找到。const dict = `<?xml version="1.0"?>` + `<book>` + `<data>` + `<meta name="` + `" content="`// 要压缩的数据应该（但不是必需的）包含频繁的数据// 子字符串，匹配字典中的字符串。const data = `<?xml version="1.0"?>
<book>
<meta name="title" content="The Go Programming Language"/>
<meta name="authors" content="Alan Donovan and Brian Kernighan"/>
<meta name="published" content="2015-10-26"/>
<meta name="isbn" content="978-0134190440"/>
<data>...</data>
</book>
`var b bytes.Buffer// 使用特制字典压缩数据。
zw, err := flate.NewWriterDict(&b, flate.DefaultCompression, []byte(dict))if err != nil {
log.Fatal(err)}if _, err := io.Copy(zw, strings.NewReader(data)); err != nil {
log.Fatal(err)}if err := zw.Close(); err != nil {
log.Fatal(err)}// 解压缩器必须使用与压缩器相同的字典。// 否则，输入可能显示为损坏。
fmt.Println("Decompressed output using the dictionary:")
zr := flate.NewReaderDict(bytes.NewReader(b.Bytes()), []byte(dict))if _, err := io.Copy(os.Stdout, zr); err != nil {
log.Fatal(err)}if err := zr.Close(); err != nil {
log.Fatal(err)}
fmt.Println()// 使用'＃'替代字典中的所有字节以直观地显示// 演示使用预设词典的大致效果。
fmt.Println("Substrings matched by the dictionary are marked with #:")
hashDict := []byte(dict)for i := range hashDict {
hashDict[i] = '#'}
zr = flate.NewReaderDict(&b, hashDict)if _, err := io.Copy(os.Stdout, zr); err != nil {
log.Fatal(err)}if err := zr.Close(); err != nil {
log.Fatal(err)}}在性能至关重要的应用中，Reset 可以用来丢弃当前的压缩器或解压缩器状态，并利用先前分配的内存快速重新初始化它们。
package mainimport ("bytes""compress/flate""io""log""os""strings")func main() {
proverbs := []string{"Don't communicate by sharing memory, share memory by communicating.\n","Concurrency is not parallelism.\n","The bigger the interface, the weaker the abstraction.\n","Documentation is for users.\n",}var r strings.Readervar b bytes.Buffer
buf := make([]byte, 32<<10)
zw, err := flate.NewWriter(nil, flate.DefaultCompression)if err != nil {
log.Fatal(err)}
zr := flate.NewReader(nil)for _, s := range proverbs {
r.Reset(s)
b.Reset()// 重置压缩器并从某些输入流编码。
zw.Reset(&b)if _, err := io.CopyBuffer(zw, &r, buf); err != nil {
log.Fatal(err)}if err := zw.Close(); err != nil {
log.Fatal(err)}// 重置解压缩器并解码为某个输出流。if err := zr.(flate.Resetter).Reset(&b, nil); err != nil {
log.Fatal(err)}if _, err := io.CopyBuffer(os.Stdout, zr, buf); err != nil {
log.Fatal(err)}if err := zr.Close(); err != nil {
log.Fatal(err)}}}DEFLATE 适用于通过网络传输压缩数据。
package mainimport ("compress/flate""fmt""io""log""strings""sync")func main() {var wg sync.WaitGroup
defer wg.Wait()// 使用io.Pipe来模拟网络连接。// 真正的网络应用程序应小心妥善关闭// 底层连接。
rp, wp := io.Pipe()// 启动一个 goroutine 来充当发射器。
wg.Add(1)
go func() {
defer wg.Done()
zw, err := flate.NewWriter(wp, flate.BestSpeed)if err != nil {
log.Fatal(err)}
b := make([]byte, 256)for _, m := range strings.Fields("A long time ago in a galaxy far, far away...") {// 我们使用一个简单的成帧格式，其中第一个字节是// 消息长度，跟随消息本身。
b[0] = uint8(copy(b[1:], m))if _, err := zw.Write(b[:1+len(m)]); err != nil {
log.Fatal(err)}// 刷新确保接收器可以读取迄今为止发送的所有数据。if err := zw.Flush(); err != nil {
log.Fatal(err)}}if err := zw.Close(); err != nil {
log.Fatal(err)}}()// 开始一个 goroutine 充当接收者。
wg.Add(1)
go func() {
defer wg.Done()
zr := flate.NewReader(rp)
b := make([]byte, 256)for {// 阅读消息长度。// 这是保证返回每个相应的// （Flush）冲洗并(Close)关闭发射器侧。if _, err := io.ReadFull(zr, b[:1]); err != nil {if err == io.EOF {break // 发射机关闭了流}
log.Fatal(err)}// 阅读邮件内容。
n := int(b[0])if _, err := io.ReadFull(zr, b[:n]); err != nil {
log.Fatal(err)}
fmt.Printf("Received %d bytes: %s\n", n, b[:n])}
fmt.Println()if err := zr.Close(); err != nil {
log.Fatal(err)}}()}Constants（常量）
func NewReader(r io.Reader) io.ReadCloser
func NewReaderDict(r io.Reader, dict []byte) io.ReadCloser
type CorruptInputError
func (e CorruptInputError) Error() string
type InternalError
func (e InternalError) Error() string
type ReadError
func (e *ReadError) Error() string
type Reader
type Resetter
type WriteError
func (e *WriteError) Error() string
type Writer
func NewWriter(w io.Writer, level int) (*Writer, error)
func NewWriterDict(w io.Writer, level int, dict []byte) (*Writer, error)
func (w *Writer) Close() error
func (w *Writer) Flush() error
func (w *Writer) Reset(dst io.Writer)
func (w *Writer) Write(data []byte) (n int, err error)
Package (Dictionary) Package (Reset) Package (Synchronization)
deflate.go deflatefast.go dict_decoder.go huffman_bit_writer.go huffman_code.go inflate.go token.go
const ( NoCompression = 0 BestSpeed = 1 BestCompression = 9 DefaultCompression = -1 // HuffmanOnly 禁用 Lempel-Ziv 匹配搜索并仅执行 Huffman // 熵编码。 此模式在压缩具有的数据时非常有用 // 已经使用LZ样式算法压缩（例如Snappy或LZ4） // 缺少熵编码器。 当压缩增益达到时 // 输入流中的某些字节比其他字节更频繁地出现。 // // 请注意，HuffmanOnly会生成一个压缩输出 // 符合RFC 1951。 也就是说，任何有效的DEFLATE解压缩器都会 // 继续能够解压缩此输出。 HuffmanOnly = -2)
func NewReader(r io.Reader) io.ReadCloser
NewReader 返回一个新的 ReadCloser，可用于读取r的未压缩版本。如果r不执行 io.ByteReader，则解压缩程序可能从r读取比所需更多的数据。完成阅读时，调用者有责任在ReadCloser上调用 Close。
NewReader 返回的 ReadCloser 也实现了Resetter。
func NewReaderDict(r io.Reader, dict []byte) io.ReadCloser
NewReaderDict 与 NewReader类似，但用预设字典初始化阅读器。返回的 Reader 的行为就像未压缩的数据流以给定的字典开始，该字典已经被读取。NewReaderDict 通常用于读取由NewWriterDict 压缩的数据。
NewReader 返回的 ReadCloser 也实现了 Resetter。
CorruptInputError 报告给定偏移处存在损坏的输入。
type CorruptInputError int64
func (e CorruptInputError) Error() string
InternalError 在 flate 代码本身中报告错误。
type InternalError string
func (e InternalError) Error() string
ReadError 报告读取输入时遇到的错误。
已弃用：不再返回。
type ReadError struct {
Offset int64 // 发生错误的字节偏移量
Err error // 底层Read返回的错误func (e *ReadError) Error() string
NewReader 所需的实际读取界面。如果传入的 io.Reader 不具有ReadByte，则 NewReader 将引入它自己的缓冲区。
type Reader interface {
io.Reader
io.ByteReader}Resetter 重置由 NewReader 或 NewReaderDict 返回的 ReadCloser 以切换到新的底层 Reader。这允许重新使用 ReadCloser 而不是分配新的。
type Resetter interface { // 重置会丢弃所有缓冲的数据并重置Resetter，就像它一样 // 最初用给定的读者初始化。 Reset(r io.Reader, dict []byte) error}WriteError 报告写入输出时遇到的错误。
已弃用：不再返回。
type WriteError struct {
Offset int64 // 发生错误的字节偏移量
Err error // 底层Write返回的错误}func (e *WriteError) Error() string
Writer 将写入数据的数据写入底层写入器（请参阅NewWriter）。
type Writer struct { // 包含已过滤或未导出的字段}func NewWriter(w io.Writer, level int) (*Writer, error)
NewWriter 返回一个新的 Writer，压缩给定级别的数据。在zlib之后，级别从 1（BestSpeed）到 9（BestCompression）; 较高的水平通常运行较慢但压缩更多。级别 0（NoCompression）不尝试任何压缩; 它只增加必要的DEFLATE成帧。级别-1（DefaultCompression）使用默认的压缩级别。等级-2（HuffmanOnly）仅使用霍夫曼压缩，为所有类型的输入提供非常快速的压缩，但会牺牲相当大的压缩效率。
如果级别在-2,9范围内，则返回的错误将为零。否则，返回的错误将不为零。
func NewWriterDict(w io.Writer, level int, dict []byte) (*Writer, error)
NewWriterDict 就像 NewWriter，但是用一个预置字典初始化新的 Writer。返回的 Writer 的行为就好像字典已经写入，而不产生任何压缩输出。写入 w 的压缩数据只能由使用相同字典初始化的 Reader 解压缩。
func (w *Writer) Close() error
关闭刷新并关闭 writer。
func (w *Writer) Flush() error
刷新将任何未决数据刷新到底层写入器。它主要用于压缩网络协议，以确保远程读取器有足够的数据来重建数据包。在数据写入之前，刷新不会返回。在没有待处理数据时调用 Flush 仍然会导致 Writer 发出至少4个字节的同步标记。如果底层编写器返回错误，Flush 将返回该错误。
在 zlib 库的术语中，Flush 等价于 Z_SYNC_FLUSH。
func (w *Writer) Reset(dst io.Writer)
重置放弃 writer 的状态，并使其等同于使用dst和w的级别和字典调用 NewWriter 或 NewWriterDict 的结果。
func (w *Writer) Write(data []byte) (n int, err error)
写入数据写入 w，最终将压缩形式的数据写入其底层写入器。