path: root/devdocs/go/compress%2Fgzip%2Findex.html

<h1> Package gzip  </h1>     <ul id="short-nav">
<li><code>import "compress/gzip"</code></li>
<li><a href="#pkg-overview" class="overviewLink">Overview</a></li>
<li><a href="#pkg-index" class="indexLink">Index</a></li>
<li><a href="#pkg-examples" class="examplesLink">Examples</a></li>
</ul>     <h2 id="pkg-overview">Overview </h2> <p>Package gzip implements reading and writing of gzip format compressed files, as specified in RFC 1952. </p>   <h4 id="example__compressingReader"> <span class="text">Example (CompressingReader)</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">// This is an example of writing a compressing reader.
// This can be useful for an HTTP client body, as shown.

const testdata = "the data to be compressed"

// This HTTP handler is just for testing purposes.
handler := http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
    zr, err := gzip.NewReader(req.Body)
    if err != nil {
        log.Fatal(err)
    }

    // Just output the data for the example.
    if _, err := io.Copy(os.Stdout, zr); err != nil {
        log.Fatal(err)
    }
})
ts := httptest.NewServer(handler)
defer ts.Close()

// The remainder is the example code.

// The data we want to compress, as an io.Reader
dataReader := strings.NewReader(testdata)

// bodyReader is the body of the HTTP request, as an io.Reader.
// httpWriter is the body of the HTTP request, as an io.Writer.
bodyReader, httpWriter := io.Pipe()

// Make sure that bodyReader is always closed, so that the
// goroutine below will always exit.
defer bodyReader.Close()

// gzipWriter compresses data to httpWriter.
gzipWriter := gzip.NewWriter(httpWriter)

// errch collects any errors from the writing goroutine.
errch := make(chan error, 1)

go func() {
    defer close(errch)
    sentErr := false
    sendErr := func(err error) {
        if !sentErr {
            errch &lt;- err
            sentErr = true
        }
    }

    // Copy our data to gzipWriter, which compresses it to
    // gzipWriter, which feeds it to bodyReader.
    if _, err := io.Copy(gzipWriter, dataReader); err != nil &amp;&amp; err != io.ErrClosedPipe {
        sendErr(err)
    }
    if err := gzipWriter.Close(); err != nil &amp;&amp; err != io.ErrClosedPipe {
        sendErr(err)
    }
    if err := httpWriter.Close(); err != nil &amp;&amp; err != io.ErrClosedPipe {
        sendErr(err)
    }
}()

// Send an HTTP request to the test server.
req, err := http.NewRequest("PUT", ts.URL, bodyReader)
if err != nil {
    log.Fatal(err)
}

// Note that passing req to http.Client.Do promises that it
// will close the body, in this case bodyReader.
resp, err := ts.Client().Do(req)
if err != nil {
    log.Fatal(err)
}

// Check whether there was an error compressing the data.
if err := &lt;-errch; err != nil {
    log.Fatal(err)
}

// For this example we don't care about the response.
resp.Body.Close()

</pre> <p>Output:</p> <pre class="output" data-language="go">the data to be compressed
</pre>      <h4 id="example__writerReader"> <span class="text">Example (WriterReader)</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">var buf bytes.Buffer
zw := gzip.NewWriter(&amp;buf)

// Setting the Header fields is optional.
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(&amp;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)
}

</pre> <p>Output:</p> <pre class="output" data-language="go">Name: a-new-hope.txt
Comment: an epic space opera by George Lucas
ModTime: 1977-05-25 00:00:00 +0000 UTC

A long time ago in a galaxy far, far away...
</pre>        <h2 id="pkg-index">Index </h2>  <ul id="manual-nav">
<li><a href="#pkg-constants">Constants</a></li>
<li><a href="#pkg-variables">Variables</a></li>
<li><a href="#Header">type Header</a></li>
<li><a href="#Reader">type Reader</a></li>
<li> <a href="#NewReader">func NewReader(r io.Reader) (*Reader, error)</a>
</li>
<li> <a href="#Reader.Close">func (z *Reader) Close() error</a>
</li>
<li> <a href="#Reader.Multistream">func (z *Reader) Multistream(ok bool)</a>
</li>
<li> <a href="#Reader.Read">func (z *Reader) Read(p []byte) (n int, err error)</a>
</li>
<li> <a href="#Reader.Reset">func (z *Reader) Reset(r io.Reader) error</a>
</li>
<li><a href="#Writer">type Writer</a></li>
<li> <a href="#NewWriter">func NewWriter(w io.Writer) *Writer</a>
</li>
<li> <a href="#NewWriterLevel">func NewWriterLevel(w io.Writer, level int) (*Writer, error)</a>
</li>
<li> <a href="#Writer.Close">func (z *Writer) Close() error</a>
</li>
<li> <a href="#Writer.Flush">func (z *Writer) Flush() error</a>
</li>
<li> <a href="#Writer.Reset">func (z *Writer) Reset(w io.Writer)</a>
</li>
<li> <a href="#Writer.Write">func (z *Writer) Write(p []byte) (int, error)</a>
</li>
</ul> <div id="pkg-examples"> <h3>Examples</h3>  <dl> <dd><a class="exampleLink" href="#example_Reader_Multistream">Reader.Multistream</a></dd> <dd><a class="exampleLink" href="#example__compressingReader">Package (CompressingReader)</a></dd> <dd><a class="exampleLink" href="#example__writerReader">Package (WriterReader)</a></dd> </dl> </div> <h3>Package files</h3> <p>  <span>gunzip.go</span> <span>gzip.go</span>  </p>   <h2 id="pkg-constants">Constants</h2> <p>These constants are copied from the flate package, so that code that imports "compress/gzip" does not also have to import "compress/flate". </p>
<pre data-language="go">const (
    NoCompression      = flate.NoCompression
    BestSpeed          = flate.BestSpeed
    BestCompression    = flate.BestCompression
    DefaultCompression = flate.DefaultCompression
    HuffmanOnly        = flate.HuffmanOnly
)</pre> <h2 id="pkg-variables">Variables</h2> <pre data-language="go">var (
    // ErrChecksum is returned when reading GZIP data that has an invalid checksum.
    ErrChecksum = errors.New("gzip: invalid checksum")
    // ErrHeader is returned when reading GZIP data that has an invalid header.
    ErrHeader = errors.New("gzip: invalid header")
)</pre> <h2 id="Header">type <span>Header</span>  </h2> <p>The gzip file stores a header giving metadata about the compressed file. That header is exposed as the fields of the <a href="#Writer">Writer</a> and <a href="#Reader">Reader</a> structs. </p>
<p>Strings must be UTF-8 encoded and may only contain Unicode code points U+0001 through U+00FF, due to limitations of the GZIP file format. </p>
<pre data-language="go">type Header struct {
    Comment string    // comment
    Extra   []byte    // "extra data"
    ModTime time.Time // modification time
    Name    string    // file name
    OS      byte      // operating system type
}
</pre> <h2 id="Reader">type <span>Reader</span>  </h2> <p>A Reader is an <span>io.Reader</span> that can be read to retrieve uncompressed data from a gzip-format compressed file. </p>
<p>In general, a gzip file can be a concatenation of gzip files, each with its own header. Reads from the Reader return the concatenation of the uncompressed data of each. Only the first header is recorded in the Reader fields. </p>
<p>Gzip files store a length and checksum of the uncompressed data. The Reader will return an <a href="#ErrChecksum">ErrChecksum</a> when <a href="#Reader.Read">Reader.Read</a> reaches the end of the uncompressed data if it does not have the expected length or checksum. Clients should treat data returned by <a href="#Reader.Read">Reader.Read</a> as tentative until they receive the <span>io.EOF</span> marking the end of the data. </p>
<pre data-language="go">type Reader struct {
    Header // valid after NewReader or Reader.Reset
    // contains filtered or unexported fields
}
</pre> <h3 id="NewReader">func <span>NewReader</span>  </h3> <pre data-language="go">func NewReader(r io.Reader) (*Reader, error)</pre> <p>NewReader creates a new <a href="#Reader">Reader</a> reading the given reader. If r does not also implement <span>io.ByteReader</span>, the decompressor may read more data than necessary from r. </p>
<p>It is the caller's responsibility to call Close on the <a href="#Reader">Reader</a> when done. </p>
<p>The [Reader.Header] fields will be valid in the <a href="#Reader">Reader</a> returned. </p>
<h3 id="Reader.Close">func (*Reader) <span>Close</span>  </h3> <pre data-language="go">func (z *Reader) Close() error</pre> <p>Close closes the <a href="#Reader">Reader</a>. It does not close the underlying <span>io.Reader</span>. In order for the GZIP checksum to be verified, the reader must be fully consumed until the <span>io.EOF</span>. </p>
<h3 id="Reader.Multistream">func (*Reader) <span>Multistream</span>  <span title="Added in Go 1.4">1.4</span> </h3> <pre data-language="go">func (z *Reader) Multistream(ok bool)</pre> <p>Multistream controls whether the reader supports multistream files. </p>
<p>If enabled (the default), the <a href="#Reader">Reader</a> expects the input to be a sequence of individually gzipped data streams, each with its own header and trailer, ending at EOF. The effect is that the concatenation of a sequence of gzipped files is treated as equivalent to the gzip of the concatenation of the sequence. This is standard behavior for gzip readers. </p>
<p>Calling Multistream(false) disables this behavior; disabling the behavior can be useful when reading file formats that distinguish individual gzip data streams or mix gzip data streams with other data streams. In this mode, when the <a href="#Reader">Reader</a> reaches the end of the data stream, <a href="#Reader.Read">Reader.Read</a> returns <span>io.EOF</span>. The underlying reader must implement <span>io.ByteReader</span> in order to be left positioned just after the gzip stream. To start the next stream, call z.Reset(r) followed by z.Multistream(false). If there is no next stream, z.Reset(r) will return <span>io.EOF</span>. </p>   <h4 id="example_Reader_Multistream"> <span class="text">Example</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">var buf bytes.Buffer
zw := gzip.NewWriter(&amp;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(&amp;buf)
}

zr, err := gzip.NewReader(&amp;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(&amp;buf)
    if err == io.EOF {
        break
    }
    if err != nil {
        log.Fatal(err)
    }
}

if err := zr.Close(); err != nil {
    log.Fatal(err)
}

</pre> <p>Output:</p> <pre class="output" data-language="go">Name: file-1.txt
Comment: file-header-1
ModTime: 2006-02-01 03:04:05 +0000 UTC

Hello Gophers - 1

Name: file-2.txt
Comment: file-header-2
ModTime: 2007-03-02 04:05:06 +0000 UTC

Hello Gophers - 2
</pre>   <h3 id="Reader.Read">func (*Reader) <span>Read</span>  </h3> <pre data-language="go">func (z *Reader) Read(p []byte) (n int, err error)</pre> <p>Read implements <span>io.Reader</span>, reading uncompressed bytes from its underlying <a href="#Reader">Reader</a>. </p>
<h3 id="Reader.Reset">func (*Reader) <span>Reset</span>  <span title="Added in Go 1.3">1.3</span> </h3> <pre data-language="go">func (z *Reader) Reset(r io.Reader) error</pre> <p>Reset discards the <a href="#Reader">Reader</a> z's state and makes it equivalent to the result of its original state from <a href="#NewReader">NewReader</a>, but reading from r instead. This permits reusing a <a href="#Reader">Reader</a> rather than allocating a new one. </p>
<h2 id="Writer">type <span>Writer</span>  </h2> <p>A Writer is an io.WriteCloser. Writes to a Writer are compressed and written to w. </p>
<pre data-language="go">type Writer struct {
    Header // written at first call to Write, Flush, or Close
    // contains filtered or unexported fields
}
</pre> <h3 id="NewWriter">func <span>NewWriter</span>  </h3> <pre data-language="go">func NewWriter(w io.Writer) *Writer</pre> <p>NewWriter returns a new <a href="#Writer">Writer</a>. Writes to the returned writer are compressed and written to w. </p>
<p>It is the caller's responsibility to call Close on the <a href="#Writer">Writer</a> when done. Writes may be buffered and not flushed until Close. </p>
<p>Callers that wish to set the fields in Writer.Header must do so before the first call to Write, Flush, or Close. </p>
<h3 id="NewWriterLevel">func <span>NewWriterLevel</span>  </h3> <pre data-language="go">func NewWriterLevel(w io.Writer, level int) (*Writer, error)</pre> <p>NewWriterLevel is like <a href="#NewWriter">NewWriter</a> but specifies the compression level instead of assuming <a href="#DefaultCompression">DefaultCompression</a>. </p>
<p>The compression level can be <a href="#DefaultCompression">DefaultCompression</a>, <a href="#NoCompression">NoCompression</a>, <a href="#HuffmanOnly">HuffmanOnly</a> or any integer value between <a href="#BestSpeed">BestSpeed</a> and <a href="#BestCompression">BestCompression</a> inclusive. The error returned will be nil if the level is valid. </p>
<h3 id="Writer.Close">func (*Writer) <span>Close</span>  </h3> <pre data-language="go">func (z *Writer) Close() error</pre> <p>Close closes the <a href="#Writer">Writer</a> by flushing any unwritten data to the underlying <span>io.Writer</span> and writing the GZIP footer. It does not close the underlying <span>io.Writer</span>. </p>
<h3 id="Writer.Flush">func (*Writer) <span>Flush</span>  <span title="Added in Go 1.1">1.1</span> </h3> <pre data-language="go">func (z *Writer) Flush() error</pre> <p>Flush flushes any pending compressed data to the underlying writer. </p>
<p>It is useful mainly in compressed network protocols, to ensure that a remote reader has enough data to reconstruct a packet. Flush does not return until the data has been written. If the underlying writer returns an error, Flush returns that error. </p>
<p>In the terminology of the zlib library, Flush is equivalent to Z_SYNC_FLUSH. </p>
<h3 id="Writer.Reset">func (*Writer) <span>Reset</span>  <span title="Added in Go 1.2">1.2</span> </h3> <pre data-language="go">func (z *Writer) Reset(w io.Writer)</pre> <p>Reset discards the <a href="#Writer">Writer</a> z's state and makes it equivalent to the result of its original state from <a href="#NewWriter">NewWriter</a> or <a href="#NewWriterLevel">NewWriterLevel</a>, but writing to w instead. This permits reusing a <a href="#Writer">Writer</a> rather than allocating a new one. </p>
<h3 id="Writer.Write">func (*Writer) <span>Write</span>  </h3> <pre data-language="go">func (z *Writer) Write(p []byte) (int, error)</pre> <p>Write writes a compressed form of p to the underlying <span>io.Writer</span>. The compressed bytes are not necessarily flushed until the <a href="#Writer">Writer</a> is closed. </p><div class="_attribution">
  <p class="_attribution-p">
    &copy; Google, Inc.<br>Licensed under the Creative Commons Attribution License 3.0.<br>
    <a href="http://golang.org/pkg/compress/gzip/" class="_attribution-link">http://golang.org/pkg/compress/gzip/</a>
  </p>
</div>