Node.js ZLIB

var gzip = zlib.creategzip();
var fs = require('fs');
var inp = fs.createreadstream('input.txt');
var out = fs.createwritestream('input.txt.gz');

inp.pipe(gzip).pipe(out);

一步压缩/解压缩数据可以通过一个简便方法来实现。

var input = '.................................';
zlib.deflate(input, function(err, buffer) {
  if (!err) {
    console.log(buffer.tostring('base64'));
  }
});

var buffer = new buffer('ejzt0ymaagtvbe8=', 'base64');
zlib.unzip(buffer, function(err, buffer) {
  if (!err) {
    console.log(buffer.tostring());
  }
});

要在一个http客户端或服务器中使用这个模块，可以在请求时使用accept-encoding，响应时使用content-encoding头。

注意: 这些例子只是简单展示了基本概念。zlib编码可能消耗非常大，并且结果可能要被缓存。更多使用 zlib 相关的速度/内存/压缩的权衡选择细节参见后面的memory usage tuning。

// client request example
var zlib = require('zlib');
var http = require('http');
var fs = require('fs');
var request = http.get({ host: 'izs.me',
                         path: '/',
                         port: 80,
                         headers: { 'accept-encoding': 'gzip,deflate' } });
request.on('response', function(response) {
  var output = fs.createwritestream('izs.me_index.html');

  switch (response.headers['content-encoding']) {
    // or, just use zlib.createunzip() to handle both cases
    case 'gzip':
      response.pipe(zlib.creategunzip()).pipe(output);
      break;
    case 'deflate':
      response.pipe(zlib.createinflate()).pipe(output);
      break;
    默认：
      response.pipe(output);
      break;
  }
});

// server example
// running a gzip operation on every request is quite expensive.
// it would be much more efficient to cache the compressed buffer.
var zlib = require('zlib');
var http = require('http');
var fs = require('fs');
http.createserver(function(request, response) {
  var raw = fs.createreadstream('index.html');
  var acceptencoding = request.headers['accept-encoding'];
  if (!acceptencoding) {
    acceptencoding = '';
  }

  // note: this is not a conformant accept-encoding parser.
  // see http://www.w3.org/protocols/rfc2616/rfc2616-sec14.html#sec14.3
  if (acceptencoding.match(/\bdeflate\b/)) {
    response.writehead(200, { 'content-encoding': 'deflate' });
    raw.pipe(zlib.createdeflate()).pipe(response);
  } else if (acceptencoding.match(/\bgzip\b/)) {
    response.writehead(200, { 'content-encoding': 'gzip' });
    raw.pipe(zlib.creategzip()).pipe(response);
  } else {
    response.writehead(200, {});
    raw.pipe(response);
  }
}).listen(1337);

zlib.creategzip([options])

根据参数options返回一个新的gzip对象。

zlib.creategunzip([options])

根据参数options返回一个新的gunzip对象。

zlib.createdeflate([options])

根据参数options返回一个新的deflate对象。

zlib.createinflate([options])

根据参数options返回一个新的inflate对象。

zlib.createdeflateraw([options])

根据参数options返回一个新的deflateraw对象。

zlib.createinflateraw([options])

根据参数options返回一个新的inflateraw对象。

zlib.createunzip([options])

根据参数options返回一个新的unzip对象。

class: zlib.zlib

这个类未被zlib模块导出。之所以写在这，是因为这是压缩/解压缩类的基类。

zlib.flush([kind], callback)

参数kind默认为zlib.z_full_flush。

刷入缓冲数据。不要轻易调用这个方法，过早的刷会对压缩算法产生负面影响。

zlib.params(level, strategy, callback)

动态更新压缩基本和压缩策略。仅对deflate算法有效。

zlib.reset()

重置压缩/解压缩为默认值。仅适用于inflate和deflate算法。

class: zlib.gzip

使用gzip压缩数据。

class: zlib.gunzip

使用gzip解压缩数据。

class: zlib.deflate

使用deflate压缩数据。

class: zlib.inflate

解压缩deflate流。

class: zlib.deflateraw

使用deflate压缩数据，不需要拼接zlib头。

class: zlib.inflateraw

解压缩一个原始deflate流。

class: zlib.unzip

通过自动检测头解压缩一个gzip-或deflate-compressed流。

简便方法

所有的这些方法第一个参数为字符串或缓存，第二个可选参数可以供zlib类使用，回调函数为callback(error, result)。

每个方法都有一个*sync伴随方法，它接收相同参数，不过没有回调。

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

zlib.deflatesync(buf[, options])

使用deflate压缩一个字符串。

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

zlib.deflaterawsync(buf[, options])

使用deflateraw压缩一个字符串。

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

zlib.gzipsync(buf[, options])

使用gzip压缩一个字符串。

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

zlib.gunzipsync(buf[, options])

使用gunzip解压缩一个原始的buffer。

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

zlib.inflatesync(buf[, options])

使用inflate解压缩一个原始的buffer。

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

zlib.inflaterawsync(buf[, options])

使用inflateraw解压缩一个原始的buffer。

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

zlib.unzipsync(buf[, options])

使用unzip解压缩一个原始的buffer。

options

每个类都有一个选项对象。所有选项都是可选的。

注意：某些选项仅在压缩时有用，解压缩时会被忽略。

flush (默认：zlib.z_no_flush)
chunksize (默认：16*1024)
windowbits
level (仅压缩有效)
memlevel (仅压缩有效)
strategy (仅压缩有效)
dictionary (仅 deflate/inflate 有效, 默认为空字典)

参见deflateinit2和inflateinit2的描述，它们位于http://zlib.net/manual.html#advanced。

使用内存调优

来自zlib/zconf.h，修改为node's的用法:

deflate的内存需求（单位：字节）：

(1 << (windowbits+2)) +  (1 << (memlevel+9))

windowbits=15的128k加memlevel = 8的128k （缺省值），加其他对象的若干kb。

例如，如果你想减少默认的内存需求（从256k减为128k），设置选项：

{ windowbits: 14, memlevel: 7 }

当然这通常会降低压缩等级。

inflate的内存需求（单位：字节）：

1 << windowbits

windowbits=15(默认值)32k 加其他对象的若干kb。

这是除了内部输出缓冲外chunksize的大小，默认为16k。

影响zlib的压缩速度最大因素为level压缩级别。level越大，压缩率越高，速度越慢，level越小，压缩率越小，速度会更快。

通常来说，使用更多的内存选项，意味着node必须减少对zlib掉哟过，因为可以在一个write操作里可以处理更多的数据。所以，这是另一个影响速度和内存使用率的因素，

常量

所有常量定义在zlib.h ，也定义在require('zlib') 。

通常的操作，基本用不到这些常量。写到文档里是想你不会对他们的存在感到惊讶。这个章节基本都来自zlibdocumentation。更多细节参见http://zlib.net/manual.html#constants。

允许flush的值：

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

压缩/解压缩函数的返回值。负数代表错误，正数代表特殊但正常的事件：

zlib.z_ok
zlib.z_stream_end
zlib.z_need_dict
zlib.z_errno
zlib.z_stream_error
zlib.z_data_error
zlib.z_mem_error
zlib.z_buf_error
zlib.z_version_error

压缩级别：

zlib.z_no_compression
zlib.z_best_speed
zlib.z_best_compression
zlib.z_default_compression

压缩策略：

zlib.z_filtered
zlib.z_huffman_only
zlib.z_rle
zlib.z_fixed
zlib.z_default_strategy

data_type字段的可能值：

zlib.z_binary
zlib.z_text
zlib.z_ascii
zlib.z_unknown

deflate的压缩方法：

zlib.z_deflated

初始化zalloc, zfree, opaque：

zlib.z_null