package gzip

Import Path
	compress/gzip (on go.dev)

Dependency Relation
	imports 8 packages, and imported by 2 packages

Involved Source Files

	  d gunzip.go
		Package gzip implements reading and writing of gzip format compressed files,
		as specified in RFC 1952.

	    gzip.go
Code Examples

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

	_compressingReader
		package main
		
		import (
			"compress/gzip"
			"io"
			"log"
			"net/http"
			"net/http/httptest"
			"os"
			"strings"
		)
		
		func main() {
			// 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 <- 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 && err != io.ErrClosedPipe {
					sendErr(err)
				}
				if err := gzipWriter.Close(); err != nil && err != io.ErrClosedPipe {
					sendErr(err)
				}
				if err := httpWriter.Close(); err != nil && 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 := <-errch; err != nil {
				log.Fatal(err)
			}
		
			// For this example we don't care about the response.
			resp.Body.Close()
		
		}

	_writerReader
		package main
		
		import (
			"bytes"
			"compress/gzip"
			"fmt"
			"io"
			"log"
			"os"
			"time"
		)
		
		func main() {
			var buf bytes.Buffer
			zw := gzip.NewWriter(&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(&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)
			}
		
		}


Package-Level Type Names (total 3, all are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Header (struct)
		The gzip file stores a header giving metadata about the compressed file.
		That header is exposed as the fields of the Writer and Reader structs.
		
		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.

		Fields (total 5, all are exported)
			Comment string
				// comment

			Extra []byte
				// "extra data"

			ModTime time.Time
				// modification time

			Name string
				// file name

			OS byte
				// operating system type

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Reader).readHeader() (hdr Header, err error)

	 type Reader (struct)
		A Reader is an io.Reader that can be read to retrieve
		uncompressed data from a gzip-format compressed file.
		
		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.
		
		Gzip files store a length and checksum of the uncompressed data.
		The Reader will return an ErrChecksum when Read
		reaches the end of the uncompressed data if it does not
		have the expected length or checksum. Clients should treat data
		returned by Read as tentative until they receive the io.EOF
		marking the end of the data.

		Fields (total 13, in which 6 are exported)
			Header Header
				// valid after NewReader or Reader.Reset

			Header.Comment string
				// comment

			Header.Extra []byte
				// "extra data"

			Header.ModTime time.Time
				// modification time

			Header.Name string
				// file name

			Header.OS byte
				// operating system type

			/* 7 unexporteds ... *//* 7 unexporteds: */
			buf [512]byte
			decompressor io.ReadCloser
			digest uint32
				// CRC-32, IEEE polynomial (section 8)

			err error
			multistream bool
			r flate.Reader
			size uint32
				// Uncompressed size (section 2.3.1)

		Methods (total 6, in which 4 are exported)
			(*Reader) Close() error
				Close closes the Reader. It does not close the underlying io.Reader.
				In order for the GZIP checksum to be verified, the reader must be
				fully consumed until the io.EOF.

			(*Reader) Multistream(ok bool)
				Multistream controls whether the reader supports multistream files.
				
				If enabled (the default), the Reader 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.
				
				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 Reader reaches the end of the data stream,
				Read returns io.EOF. The underlying reader must implement io.ByteReader
				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 io.EOF.

			(*Reader) Read(p []byte) (n int, err error)
				Read implements io.Reader, reading uncompressed bytes from its underlying Reader.

			(*Reader) Reset(r io.Reader) error
				Reset discards the Reader z's state and makes it equivalent to the
				result of its original state from NewReader, but reading from r instead.
				This permits reusing a Reader rather than allocating a new one.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*Reader) readHeader() (hdr Header, err error)
				readHeader reads the GZIP header according to section 2.3.1.
				This method does not set z.err.

			(*Reader) readString() (string, error)
				readString reads a NUL-terminated string from z.r.
				It treats the bytes read as being encoded as ISO 8859-1 (Latin-1) and
				will output a string encoded using UTF-8.
				This method always updates z.digest with the data read.

		Implements (at least 3, all are exported)
			*Reader : io.Closer
			*Reader : io.ReadCloser
			*Reader : io.Reader
		As Outputs Of (at least one exported)
			func NewReader(r io.Reader) (*Reader, error)

	 type Writer (struct)
		A Writer is an io.WriteCloser.
		Writes to a Writer are compressed and written to w.

		Fields (total 15, in which 6 are exported)
			Header Header
				// written at first call to Write, Flush, or Close

			Header.Comment string
				// comment

			Header.Extra []byte
				// "extra data"

			Header.ModTime time.Time
				// modification time

			Header.Name string
				// file name

			Header.OS byte
				// operating system type

			/* 9 unexporteds ... *//* 9 unexporteds: */
			buf [10]byte
			closed bool
			compressor *flate.Writer
			digest uint32
				// CRC-32, IEEE polynomial (section 8)

			err error
			level int
			size uint32
				// Uncompressed size (section 2.3.1)

			w io.Writer
			wroteHeader bool
		Methods (total 7, in which 4 are exported)
			(*Writer) Close() error
				Close closes the Writer by flushing any unwritten data to the underlying
				io.Writer and writing the GZIP footer.
				It does not close the underlying io.Writer.

			(*Writer) Flush() error
				Flush flushes any pending compressed data to the underlying writer.
				
				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.
				
				In the terminology of the zlib library, Flush is equivalent to Z_SYNC_FLUSH.

			(*Writer) Reset(w io.Writer)
				Reset discards the Writer z's state and makes it equivalent to the
				result of its original state from NewWriter or NewWriterLevel, but
				writing to w instead. This permits reusing a Writer rather than
				allocating a new one.

			(*Writer) Write(p []byte) (int, error)
				Write writes a compressed form of p to the underlying io.Writer. The
				compressed bytes are not necessarily flushed until the Writer is closed.

			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*Writer) init(w io.Writer, level int)
			(*Writer) writeBytes(b []byte) error
				writeBytes writes a length-prefixed byte slice to z.w.

			(*Writer) writeString(s string) (err error)
				writeString writes a UTF-8 string s in GZIP's format to z.w.
				GZIP (RFC 1952) specifies that strings are NUL-terminated ISO 8859-1 (Latin-1).

		Implements (at least 5, in which 4 are exported)
			*Writer : internal/bisect.Writer
			*Writer : io.Closer
			*Writer : io.WriteCloser
			*Writer : io.Writer
			/* at least one unexported ... *//* at least one unexported: */
			*Writer : crypto/tls.transcriptHash
		As Outputs Of (at least 2, both are exported)
			func NewWriter(w io.Writer) *Writer
			func NewWriterLevel(w io.Writer, level int) (*Writer, error)


Package-Level Functions (total 4, in which 3 are exported)

	 func NewReader(r io.Reader) (*Reader, error)
		NewReader creates a new Reader reading the given reader.
		If r does not also implement io.ByteReader,
		the decompressor may read more data than necessary from r.
		
		It is the caller's responsibility to call Close on the Reader when done.
		
		The Reader.Header fields will be valid in the Reader returned.

	 func NewWriter(w io.Writer) *Writer
		NewWriter returns a new Writer.
		Writes to the returned writer are compressed and written to w.
		
		It is the caller's responsibility to call Close on the Writer when done.
		Writes may be buffered and not flushed until Close.
		
		Callers that wish to set the fields in Writer.Header must do so before
		the first call to Write, Flush, or Close.

	 func NewWriterLevel(w io.Writer, level int) (*Writer, error)
		NewWriterLevel is like NewWriter but specifies the compression level instead
		of assuming DefaultCompression.
		
		The compression level can be DefaultCompression, NoCompression, HuffmanOnly
		or any integer value between BestSpeed and BestCompression inclusive.
		The error returned will be nil if the level is valid.

	/* one unexported ... *//* one unexported: */
	 func noEOF(err error) error
		noEOF converts io.EOF to io.ErrUnexpectedEOF.


Package-Level Variables (total 3, in which 2 are exported)

	  var ErrChecksum error
		ErrChecksum is returned when reading GZIP data that has an invalid checksum.

	  var ErrHeader error
		ErrHeader is returned when reading GZIP data that has an invalid header.

	/* one unexported ... *//* one unexported: */
	  var le binary.littleEndian
Package-Level Constants (total 13, in which 5 are exported)

	const BestCompression = 9
		These constants are copied from the flate package, so that code that imports
		"compress/gzip" does not also have to import "compress/flate".

	const BestSpeed = 1
		These constants are copied from the flate package, so that code that imports
		"compress/gzip" does not also have to import "compress/flate".

	const DefaultCompression = -1
		These constants are copied from the flate package, so that code that imports
		"compress/gzip" does not also have to import "compress/flate".

	const HuffmanOnly = -2
		These constants are copied from the flate package, so that code that imports
		"compress/gzip" does not also have to import "compress/flate".

	const NoCompression = 0
		These constants are copied from the flate package, so that code that imports
		"compress/gzip" does not also have to import "compress/flate".

	/* 8 unexporteds ... *//* 8 unexporteds: */
	const flagComment = 16
	const flagExtra = 4
	const flagHdrCrc = 2
	const flagName = 8
	const flagText = 1
	const gzipDeflate = 8
	const gzipID1 = 31
	const gzipID2 = 139

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.