Zlib

    This provides bindings to Gzip/Gunzip, Deflate/Inflate, and
    DeflateRaw/InflateRaw classes. Each class takes the same options, and
    is a readable/writable Stream.

    Compressing or decompressing a file can be done by piping an
    fs.ReadStream into a zlib stream, then into an fs.WriteStream.

    Compressing or decompressing data in one step can be done by using
    the convenience methods.

    1. var input = '.................................';
    2. zlib.deflate(input, function(err, buffer) {
    3.   if (!err) {
    4.     console.log(buffer.toString('base64'));
    5.   }
    6. });
    8. var buffer = new Buffer('eJzT0yMAAGTvBe8=', 'base64');
    9. zlib.unzip(buffer, function(err, buffer) {
    10.   if (!err) {
    11.     console.log(buffer.toString());
    12.   }
    13. });

    To use this module in an HTTP client or server, use the
    accept-encoding
    on requests, and the

    header on responses.

    Note: these examples are drastically simplified to show
    the basic concept.     Zlib encoding can be expensive, and the results
    ought to be cached. See Memory Usage Tuning
    below for more information on the speed/memory/compression
    tradeoffs involved in zlib usage.

    zlib.createGzip([options])

    Returns a new Gzip object with an
    .

    zlib.createGunzip([options])

    Returns a new object with an
    options.

    zlib.createDeflate([options])

    Returns a new Deflate object with an
    .

    zlib.createInflate([options])

    Returns a new object with an
    options.

    zlib.createDeflateRaw([options])

    Returns a new DeflateRaw object with an
    .

    zlib.createInflateRaw([options])

    Returns a new object with an
    options.

    zlib.createUnzip([options])

    Returns a new Unzip object with an
    .

    Class: zlib.Zlib

    Not exported by the zlib module. It is documented here because it is the base
    class of the compressor/decompressor classes.

    kind defaults to zlib.Z_FULL_FLUSH.

    Flush pending data. Don’t call this frivolously, premature flushes negatively
    impact the effectiveness of the compression algorithm.

    Dynamically update the compression level and compression strategy.
    Only applicable to deflate algorithm.

    Reset the compressor/decompressor to factory defaults. Only applicable to
    the inflate and deflate algorithms.

    Class: zlib.Gzip

    Class: zlib.Gunzip

    Decompress a gzip stream.

    Compress data using deflate.

    Class: zlib.Inflate

    Decompress a deflate stream.

    Class: zlib.DeflateRaw

    Compress data using deflate, and do not append a zlib header.

    Class: zlib.InflateRaw

    Decompress a raw deflate stream.

    Class: zlib.Unzip

    Decompress either a Gzip- or Deflate-compressed stream by auto-detecting
    the header.

    Convenience Methods

    All of these take a string or buffer as the first argument, an optional second
    argument to supply options to the zlib classes and will call the supplied
    callback with callback(error, result).

    Every method has a *Sync counterpart, which accept the same arguments, but
    without a callback.

    zlib.deflate(buf[, options], callback)

    zlib.deflateSync(buf[, options])

    Compress a string with Deflate.

    zlib.deflateRaw(buf[, options], callback)

    zlib.deflateRawSync(buf[, options])

    Compress a string with DeflateRaw.

    zlib.gzip(buf[, options], callback)

    Compress a string with Gzip.

    zlib.gunzip(buf[, options], callback)

    zlib.gunzipSync(buf[, options])

    Decompress a raw Buffer with Gunzip.

    zlib.inflate(buf[, options], callback)

    zlib.inflateSync(buf[, options])

    Decompress a raw Buffer with Inflate.

    zlib.inflateRaw(buf[, options], callback)

    zlib.inflateRawSync(buf[, options])

    Decompress a raw Buffer with InflateRaw.

    zlib.unzip(buf[, options], callback)

    zlib.unzipSync(buf[, options])

    Decompress a raw Buffer with Unzip.

    Options

    Each class takes an options object. All options are optional.

    Note that some options are only relevant when compressing, and are
    ignored by the decompression classes.

    • flush (default: zlib.Z_NO_FLUSH)
    • chunkSize (default: 16*1024)
    • windowBits
    • level (compression only)
    • memLevel (compression only)
    • strategy (compression only)
    • dictionary (deflate/inflate only, empty dictionary by default)

    Memory Usage Tuning

    From zlib/zconf.h, modified to node’s usage:

    The memory requirements for deflate are (in bytes):

    1. (1 << (windowBits+2)) +  (1 << (memLevel+9))

    that is: 128K for windowBits=15 + 128K for memLevel = 8
    (default values) plus a few kilobytes for small objects.

    For example, if you want to reduce
    the default memory requirements from 256K to 128K, set the options to:

    Of course this will generally degrade compression (there’s no free lunch).

    The memory requirements for inflate are (in bytes)

      that is, 32K for windowBits=15 (default value) plus a few kilobytes
      for small objects.

      This is in addition to a single internal output slab buffer of size
      chunkSize, which defaults to 16K.

      The speed of zlib compression is affected most dramatically by the
      level setting. A higher level will result in better compression, but
      will take longer to complete. A lower level will result in less
      compression, but will be much faster.

      In general, greater memory usage options will mean that node has to make
      fewer calls to zlib, since it’ll be able to process more data in a
      single write operation. So, this is another factor that affects the
      speed, at the cost of memory usage.

      All of the constants defined in zlib.h are also defined on
      require('zlib').
      In the normal course of operations, you will not need to ever set any of
      these. They are documented here so that their presence is not
      surprising. This section is taken almost directly from the . See
      http://zlib.net/manual.html#Constants for more details.

      Allowed flush values.

      • zlib.Z_NO_FLUSH
      • zlib.Z_PARTIAL_FLUSH
      • zlib.Z_SYNC_FLUSH
      • zlib.Z_FULL_FLUSH
      • zlib.Z_FINISH
      • zlib.Z_BLOCK
      • zlib.Z_TREES

      Return codes for the compression/decompression functions. Negative
      values are errors, positive values are used for special but normal
      events.

      • zlib.Z_OK
      • zlib.Z_STREAM_END
      • zlib.Z_NEED_DICT
      • zlib.Z_ERRNO
      • zlib.Z_DATA_ERROR
      • zlib.Z_MEM_ERROR
      • zlib.Z_BUF_ERROR
      • zlib.Z_VERSION_ERROR

      Compression levels.

      • zlib.Z_NO_COMPRESSION
      • zlib.Z_BEST_SPEED
      • zlib.Z_BEST_COMPRESSION
      • zlib.Z_DEFAULT_COMPRESSION

      Compression strategy.

      • zlib.Z_FILTERED
      • zlib.Z_HUFFMAN_ONLY
      • zlib.Z_RLE
      • zlib.Z_FIXED
      • zlib.Z_DEFAULT_STRATEGY

      Possible values of the data_type field.

      • zlib.Z_BINARY
      • zlib.Z_TEXT
      • zlib.Z_ASCII
      • zlib.Z_UNKNOWN

      The deflate compression method (the only one supported in this version).

      • zlib.Z_NULL