direktori cari
archive archive/tar archive/zip bufio bufio(缓存) builtin builtin(内置包) bytes bytes(包字节) compress compress/bzip2(压缩/bzip2) compress/flate(压缩/flate) compress/gzip(压缩/gzip) compress/lzw(压缩/lzw) compress/zlib(压缩/zlib) container container/heap(容器数据结构heap) container/list(容器数据结构list) container/ring(容器数据结构ring) context context(上下文) crypto crypto(加密) crypto/aes(加密/aes) crypto/cipher(加密/cipher) crypto/des(加密/des) crypto/dsa(加密/dsa) crypto/ecdsa(加密/ecdsa) crypto/elliptic(加密/elliptic) crypto/hmac(加密/hmac) crypto/md5(加密/md5) crypto/rand(加密/rand) crypto/rc4(加密/rc4) crypto/rsa(加密/rsa) crypto/sha1(加密/sha1) crypto/sha256(加密/sha256) crypto/sha512(加密/sha512) crypto/subtle(加密/subtle) crypto/tls(加密/tls) crypto/x509(加密/x509) crypto/x509/pkix(加密/x509/pkix) database database/sql(数据库/sql) database/sql/driver(数据库/sql/driver) debug debug/dwarf(调试/dwarf) debug/elf(调试/elf) debug/gosym(调试/gosym) debug/macho(调试/macho) debug/pe(调试/pe) debug/plan9obj(调试/plan9obj) encoding encoding(编码) encoding/ascii85(编码/ascii85) encoding/asn1(编码/asn1) encoding/base32(编码/base32) encoding/base64(编码/base64) encoding/binary(编码/binary) encoding/csv(编码/csv) encoding/gob(编码/gob) encoding/hex(编码/hex) encoding/json(编码/json) encoding/pem(编码/pem) encoding/xml(编码/xml) errors errors(错误) expvar expvar flag flag(命令行参数解析flag包) fmt fmt go go/ast(抽象语法树) go/build go/constant(常量) go/doc(文档) go/format(格式) go/importer go/parser go/printer go/scanner(扫描仪) go/token(令牌) go/types(类型) hash hash(散列) hash/adler32 hash/crc32 hash/crc64 hash/fnv html html html/template(模板) image image(图像) image/color(颜色) image/color/palette(调色板) image/draw(绘图) image/gif image/jpeg image/png index index/suffixarray io io io/ioutil log log log/syslog(日志系统) math math math/big math/big math/bits math/bits math/cmplx math/cmplx math/rand math/rand mime mime mime/multipart(多部分) mime/quotedprintable net net net/http net/http net/http/cgi net/http/cookiejar net/http/fcgi net/http/httptest net/http/httptrace net/http/httputil net/http/internal net/http/pprof net/mail net/mail net/rpc net/rpc net/rpc/jsonrpc net/smtp net/smtp net/textproto net/textproto net/url net/url os os os/exec os/signal os/user path path path/filepath(文件路径) plugin plugin(插件) reflect reflect(反射) regexp regexp(正则表达式) regexp/syntax runtime runtime(运行时) runtime/debug(调试) runtime/internal/sys runtime/pprof runtime/race(竞争) runtime/trace(执行追踪器) sort sort(排序算法) strconv strconv(转换) strings strings(字符串) sync sync(同步) sync/atomic(原子操作) syscall syscall(系统调用) testing testing(测试) testing/iotest testing/quick text text/scanner(扫描文本) text/tabwriter text/template(定义模板) text/template/parse time time(时间戳) unicode unicode unicode/utf16 unicode/utf8 unsafe unsafe
watak

  • 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

func NewReader(r io.Reader) io.ReadCloser

NewReader 返回一个新的 ReadCloser,可用于读取r的未压缩版本。如果r不执行 io.ByteReader,则解压缩程序可能从r读取比所需更多的数据。完成阅读时,调用者有责任在ReadCloser上调用 Close。

NewReader 返回的 ReadCloser 也实现了Resetter。

func NewReaderDict

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

NewReaderDict 与 NewReader类似,但用预设字典初始化阅读器。返回的 Reader 的行为就像未压缩的数据流以给定的字典开始,该字典已经被读取。NewReaderDict 通常用于读取由NewWriterDict 压缩的数据。

NewReader 返回的 ReadCloser 也实现了 Resetter。

type CorruptInputError

CorruptInputError 报告给定偏移处存在损坏的输入。

type CorruptInputError int64

func (CorruptInputError) Error

func (e CorruptInputError) Error() string

type InternalError

InternalError 在 flate 代码本身中报告错误。

type InternalError string

func (InternalError) Error

func (e InternalError) Error() string

type ReadError

ReadError 报告读取输入时遇到的错误。

已弃用:不再返回。

type ReadError struct {
        Offset int64 // 发生错误的字节偏移量
        Err    error // 底层Read返回的错误

func (*ReadError) Error

func (e *ReadError) Error() string

type Reader

NewReader 所需的实际读取界面。如果传入的 io.Reader 不具有ReadByte,则 NewReader 将引入它自己的缓冲区。

type Reader interface {
        io.Reader
        io.ByteReader}

type Resetter

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

type Resetter interface {        // 重置会丢弃所有缓冲的数据并重置Resetter,就像它一样        // 最初用给定的读者初始化。        Reset(r io.Reader, dict []byte) error}

type WriteError

WriteError 报告写入输出时遇到的错误。

已弃用:不再返回。

type WriteError struct {
        Offset int64 // 发生错误的字节偏移量
        Err    error // 底层Write返回的错误}

func (*WriteError) Error

func (e *WriteError) Error() string

type Writer

Writer 将写入数据的数据写入底层写入器(请参阅NewWriter)。

type Writer struct {        // 包含已过滤或未导出的字段}

func NewWriter

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

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

NewWriterDict 就像 NewWriter,但是用一个预置字典初始化新的 Writer。返回的 Writer 的行为就好像字典已经写入,而不产生任何压缩输出。写入 w 的压缩数据只能由使用相同字典初始化的 Reader 解压缩。

func (*Writer) Close

func (w *Writer) Close() error

关闭刷新并关闭 writer。

func (*Writer) Flush

func (w *Writer) Flush() error

刷新将任何未决数据刷新到底层写入器。它主要用于压缩网络协议,以确保远程读取器有足够的数据来重建数据包。在数据写入之前,刷新不会返回。在没有待处理数据时调用 Flush 仍然会导致 Writer 发出至少4个字节的同步标记。如果底层编写器返回错误,Flush 将返回该错误。

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

func (*Writer) Reset

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

重置放弃 writer 的状态,并使其等同于使用dst和w的级别和字典调用 NewWriter 或 NewWriterDict 的结果。

func (*Writer) Write

func (w *Writer) Write(data []byte) (n int, err error)

写入数据写入 w,最终将压缩形式的数据写入其底层写入器。

Artikel sebelumnya: Artikel seterusnya: