压缩/gzip | compress/gzip

• import "compress/gzip"

• 概述

• 索引

• 示例

概述

软件包 gzip 实现读写 gzip 格式压缩文件，如RFC 1952中所述。

示例（WriterReader）

package main

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

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

	// 设置标题字段是可选的。
	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)
	}

}

索引

Constants（常量）

Variables（变量）

type Header

type Reader

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

• func (z *Reader) Close() error

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

• func (z *Reader) Read(p []byte) (n int, err error)

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

type Writer

• func NewWriter(w io.Writer) *Writer

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

• func (z *Writer) Close() error

• func (z *Writer) Flush() error

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

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

示例

Reader.Multistream Package (WriterReader)

打包文件

gunzip.go gzip.go

常量

这些常量是从 flate 包中复制，因此导入“compress/gzip”的代码不需要导入“compress/flate”。

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

变量

var (
        // 读取具有无效校验和的GZIP数据时，会返回ErrChecksum。
        ErrChecksum = errors.New("gzip: invalid checksum")
        // 读取包含无效标题的GZIP数据时将返回ErrHeader。
        ErrHeader = errors.New("gzip: invalid header")
)

type Header（查看源代码）

gzip 文件存储一个头文件，提供有关压缩文件的元数据。这个头文件在 Writer 和 Reader 的字段结构中暴露出来。

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

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

type Reader（查看源代码）

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

通常，gzip 文件可以是 gzip 文件的连接，每个文件都有自己的头文件。从 Reader 读取返回每个的未压缩数据的连接。只有第一个标题被记录在 Reader 字段中。

Gzip 文件存储未压缩数据的长度和校验和。如果 Read未达到预期的长度或校验和，Reader 将在 Read 达到未压缩数据的末尾时返回 ErrChecksum。客户应将由 Read 返回的数据视为临时数据，直到他们收到标记数据结束的 io.EOF。

type Reader struct {
        Header // 在NewReader或Reader.Reset之后有效
        // 包含过滤或未导出的字段
}

func NewReader（查看源代码）

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

NewReader 创建一个阅读给定阅读器的新 Reader。如果 r 不执行io.ByteReader，则解压缩程序可能从 r 读取比所需更多的数据。

完成后 caller 有责任在 Reader 上调用 Close。

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

func (*Reader) Close（查看源代码）

func (z *Reader) Close() error

关闭 Reader。它不会关闭底层的 io.Reader。为了验证 GZIP校验和，阅读器必须充分消耗，直到 io.EOF。

func (*Reader) Multistream（查看源代码）

func (z *Reader) Multistream(ok bool)

多流控制阅读器是否支持多流文件。

如果启用（the default 默认），则 Reader 将输入为单独压缩数据流的序列，每个数据流都有自己的头和尾部，以 EOF 结尾。其效果是将一系列 gzip 文件的串联视为等同于串联的 gzip。这是 gzip 阅读器的标准行为。

调用 Multistream（false）会禁用此行为；在阅读区分各个 gzip 数据流或将 gzip 数据流与其他数据流混合的文件格式时，禁用此行为可能很有用。在这种模式下，当 Reader到达数据流的末尾时，Reader 返回 io.EOF。如果底层的阅读器实现 io.ByteReader，它将被放置在 gzip 流的后面。要开始下一个流，请调用z.Reset(r)，然后再调用 z.Multistream(false)。如果没有下一个流，则 z.Reset(r)将返回 io.EOF。

示例

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)
	}

}

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

重置将丢弃 Reader z的状态，并使其等同于 NewReader 中原始状态的结果，而是从 r 读取 。这允许重新使用 Reader 而不是分配新的 Reader。

type Writer（查看源代码）

Writer 是一个 io.WriteCloser。写入 Writer 被压缩并写入w。

type Writer struct {
        Header // 在第一次写入Write，Flush或Close时写入
        // 包含过滤或未导出的字段
}

func NewWriter（查看源代码）

func NewWriter(w io.Writer) *Writer

NewWriter 返回一个新的 Writer。写入返回的 writer 将被压缩并写入 w。

调用者有责任在完成时调用 WriteCloser 上的 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 之间的任何整数值。如果级别有效，返回的错误将为零。

func (*Writer) Close（查看源代码）

func (z *Writer) Close() error

通过将任何未写入的数据清空到底层的 io.Writer 并写入GZIP页脚，Close 关闭 Writer。它不关闭潜在的 io.Writer。

func (*Writer) Flush（查看源代码）

func (z *Writer) Flush() error

刷新将任何未决的压缩数据刷新到底层写入器。

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

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

func (*Writer) Reset（查看源代码）

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

重置放弃 Writer z 的状态，并使其等同于 NewWriter 或NewWriterLevel 的原始状态的结果，而是写入 w。这允许重新使用 Writer 而不是分配新的。

func (*Writer) Write（查看源代码）

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

写入一个压缩形式的 p 到底层的 io.Writer 。在 Writer 关闭之前，压缩的字节不一定会被刷新。