Golang标准库——compress/gzip

DevilRoshan · · 337 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

gzip

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

Constants

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

这些常量都是拷贝自flate包,因此导入"compress/gzip"后,就不必再导入"compress/flate"了。

Variables

var (
    // 当读取的gzip数据的校验和错误时,会返回ErrChecksum
    ErrChecksum = errors.New("gzip: invalid checksum")
    // 当读取的gzip数据的头域错误时,会返回ErrHeader
    ErrHeader = errors.New("gzip: invalid header")
)

type Header

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

gzip文件保存一个头域,提供关于被压缩的文件的一些元数据。该头域作为Writer和Reader类型的一个可导出字段,可以提供给调用者访问。

type Reader

type Reader struct {
    Header       // valid after NewReader or Reader.Reset
    r            flate.Reader
    decompressor io.ReadCloser
    digest       uint32 // CRC-32, IEEE polynomial (section 8)
    size         uint32 // Uncompressed size (section 2.3.1)
    buf          [512]byte
    err          error
    multistream  bool
}

Reader类型满足io.Reader接口,可以从gzip格式压缩文件读取并解压数据。

一般,一个gzip文件可以是多个gzip文件的串联,每一个都有自己的头域。从Reader读取数据会返回串联的每个文件的解压数据,但只有第一个文件的头域被记录在Reader的Header字段里。

gzip文件会保存未压缩数据的长度与校验和。当读取到未压缩数据的结尾时,如果数据的长度或者校验和不正确,Reader会返回ErrCheckSum。因此,调用者应该将Read方法返回的数据视为暂定的,直到他们在数据结尾获得了一个io.EOF。

func NewReader

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

NewReader返回一个从r读取并解压数据的*Reader。其实现会缓冲输入流的数据,并可能从r中读取比需要的更多的数据。调用者有责任在读取完毕后调用返回值的Close方法。

func (*Reader) Reset

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

Reset将z重置,丢弃当前的读取状态,并将下层读取目标设为r。效果上等价于将z设为使用r重新调用NewReader返回的Reader。这让我们可以重用z而不是再申请一个新的。(因此效率更高)

func (*Reader) Read

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

func (*Reader) Close

func (z *Reader) Close() error

调用Close会关闭z,但不会关闭下层io.Reader接口。

func main() {
   // 压缩
   tarFile := "C:/Users/Administrator/Downloads/test001/demo.tar.gz"
   dest := "C:/Users/Administrator/Downloads/test001/"

   srcFile, err := os.Open(tarFile)
   if err != nil {
      fmt.Println(err)
      return
   }
   defer srcFile.Close()
   gr, err := gzip.NewReader(srcFile)
   if err != nil {
      fmt.Println(err)
      return
   }
   defer gr.Close()
   tr := tar.NewReader(gr)
   for {
      hdr, err := tr.Next()
      if err != nil {
         if err == io.EOF {
            break
         } else {
            fmt.Println(err)
            return
         }
      }
      filename := dest + hdr.Name
      err = os.MkdirAll(string([]rune(filename)[0:strings.LastIndex(filename, "/")]), 0755)
      if err != nil {
         fmt.Println(err)
         return
      }
      file, _ := os.Create(filename)
      io.Copy(file, tr)
   }
}

解压文件 tar.gz,先压缩gzip,再解tar包

type Writer

type Writer struct {
    Header      // written at first call to Write, Flush, or Close
    w           io.Writer
    level       int
    wroteHeader bool
    compressor  *flate.Writer
    digest      uint32 // CRC-32, IEEE polynomial (section 8)
    size        uint32 // Uncompressed size (section 2.3.1)
    closed      bool
    buf         [10]byte
    err         error
}

Writer满足io.WriteCloser接口。它会将提供给它的数据压缩后写入下层io.Writer接口。

func NewWriter

func NewWriter(w io.Writer) *Writer

NewWriter创建并返回一个Writer。写入返回值的数据都会在压缩后写入w。调用者有责任在结束写入后调用返回值的Close方法。因为写入的数据可能保存在缓冲中没有刷新入下层。

如要设定Writer.Header字段,调用者必须在第一次调用Write方法或者Close方法之前设置。Header字段的Comment和Name字段是go的utf-8字符串,但下层格式要求为NUL中止的ISO 8859-1 (Latin-1)序列。如果这两个字段的字符串包含NUL或非Latin-1字符,将导致Write方法返回错误。

func NewWriterLevel

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

NewWriterLevel类似NewWriter但指定了压缩水平而不是采用默认的DefaultCompression。

参数level可以是DefaultCompression、NoCompression或BestSpeed与BestCompression之间包括二者的任何整数。如果level合法,返回的错误值为nil。

func (*Writer) Reset

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

Reset将z重置,丢弃当前的写入状态,并将下层输出目标设为dst。效果上等价于将w设为使用dst和w的压缩水平重新调用NewWriterLevel返回的*Writer。这让我们可以重用z而不是再申请一个新的。(因此效率更高)

func (*Writer) Write

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

Write将p压缩后写入下层io.Writer接口。压缩后的数据不一定会立刻刷新,除非Writer被关闭或者显式的刷新。

func (*Writer) Flush

func (z *Writer) Flush() error

Flush将缓冲中的压缩数据刷新到下层io.Writer接口中。

本方法主要用在传输压缩数据的网络连接中,以保证远端的接收者可以获得足够的数据来重构数据报。Flush会阻塞直到所有缓冲中的数据都写入下层io.Writer接口后才返回。如果下层的io.Writetr接口返回一个错误,Flush也会返回该错误。在zlib包的术语中,Flush方法等价于Z_SYNC_FLUSH。

func (*Writer) Close

func (z *Writer) Close() error

调用Close会关闭z,但不会关闭下层io.Writer接口。

func main() {
   // 压缩
   dest := "C:/Users/Administrator/Downloads/test001/demo.tar.gz"
   d, _ := os.Create(dest)

   defer d.Close()
   gw := gzip.NewWriter(d)
   defer gw.Close()
   tw := tar.NewWriter(gw)
   defer tw.Close()
   file_dirs := []string{"C:/Users/Administrator/Downloads/test001/test01.sh", "C:/Users/Administrator/Downloads/test001/test02.sh"}

   var files []*os.File
   for _, dir := range file_dirs {
      file, _ := os.Open(dir)
      files = append(files, file)
   }

   for _, file := range files {
      info, err := file.Stat()
      if err != nil {
         fmt.Println(err)
         return
      }
      header, err := tar.FileInfoHeader(info, "")
      if err != nil {
         fmt.Println(err)
         return
      }
      err = tw.WriteHeader(header)
      if err != nil {
         fmt.Println(err)
         return
      }
      _, err = io.Copy(tw, file)
      file.Close()
      if err != nil {
         fmt.Println(err)
         return
      }
   }
}

压缩文件 tar与gzip结合,,再打tar包,再压缩


有疑问加站长微信联系(非本文作者)

本文来自:简书

感谢作者:DevilRoshan

查看原文:Golang标准库——compress/gzip

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:701969077

337 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传