- assert 断言
- async_hooks 异步钩子
- async_hooks/context 异步上下文
- buffer 缓冲区
- C++插件
- C/C++插件(使用 Node-API)
- C++嵌入器
- child_process 子进程
- cluster 集群
- CLI 命令行
- console 控制台
- Corepack 核心包
- crypto 加密
- crypto/webcrypto 网络加密
- debugger 调试器
- deprecation 弃用
- dgram 数据报
- diagnostics_channel 诊断通道
- dns 域名服务器
- domain 域
- Error 错误
- events 事件触发器
- fs 文件系统
- global 全局变量
- http 超文本传输协议
- http2 超文本传输协议 2.0
- https 安全超文本传输协议
- inspector 检查器
- Intl 国际化
- module 模块
- module/cjs CommonJS 模块
- module/esm ECMAScript 模块
- module/package 包模块
- net 网络
- os 操作系统
- path 路径
- perf_hooks 性能钩子
- permission 权限
- process 进程
- punycode 域名代码
- querystring 查询字符串
- readline 逐行读取
- repl 交互式解释器
- report 诊断报告
- stream 流
- stream/web 网络流
- string_decoder 字符串解码器
- test 测试
- timers 定时器
- tls 安全传输层
- trace_events 跟踪事件
- tty 终端
- url 网址
- util 实用工具
- v8 引擎
- vm 虚拟机
- wasi 网络汇编系统接口
- worker_threads 工作线程
- zlib 压缩
Node.js v16.20.0 文档
- Node.js v16.20.0
-
目录
- Zlib
- 线程池使用和性能注意事项
- 压缩 HTTP 请求和响应
- 内存使用调整
- 刷新
- 常量
- 类:
Options
- 类:
BrotliOptions
- 类:
zlib.BrotliCompress
- 类:
zlib.BrotliDecompress
- 类:
zlib.Deflate
- 类:
zlib.DeflateRaw
- 类:
zlib.Gunzip
- 类:
zlib.Gzip
- 类:
zlib.Inflate
- 类:
zlib.InflateRaw
- 类:
zlib.Unzip
- 类:
zlib.ZlibBase
zlib.constants
zlib.createBrotliCompress([options])
zlib.createBrotliDecompress([options])
zlib.createDeflate([options])
zlib.createDeflateRaw([options])
zlib.createGunzip([options])
zlib.createGzip([options])
zlib.createInflate([options])
zlib.createInflateRaw([options])
zlib.createUnzip([options])
- 便捷方法
zlib.brotliCompress(buffer[, options], callback)
zlib.brotliCompressSync(buffer[, options])
zlib.brotliDecompress(buffer[, options], callback)
zlib.brotliDecompressSync(buffer[, options])
zlib.deflate(buffer[, options], callback)
zlib.deflateSync(buffer[, options])
zlib.deflateRaw(buffer[, options], callback)
zlib.deflateRawSync(buffer[, options])
zlib.gunzip(buffer[, options], callback)
zlib.gunzipSync(buffer[, options])
zlib.gzip(buffer[, options], callback)
zlib.gzipSync(buffer[, options])
zlib.inflate(buffer[, options], callback)
zlib.inflateSync(buffer[, options])
zlib.inflateRaw(buffer[, options], callback)
zlib.inflateRawSync(buffer[, options])
zlib.unzip(buffer[, options], callback)
zlib.unzipSync(buffer[, options])
- Zlib
-
导航
- assert 断言
- async_hooks 异步钩子
- async_hooks/context 异步上下文
- buffer 缓冲区
- C++插件
- C/C++插件(使用 Node-API)
- C++嵌入器
- child_process 子进程
- cluster 集群
- CLI 命令行
- console 控制台
- Corepack 核心包
- crypto 加密
- crypto/webcrypto 网络加密
- debugger 调试器
- deprecation 弃用
- dgram 数据报
- diagnostics_channel 诊断通道
- dns 域名服务器
- domain 域
- Error 错误
- events 事件触发器
- fs 文件系统
- global 全局变量
- http 超文本传输协议
- http2 超文本传输协议 2.0
- https 安全超文本传输协议
- inspector 检查器
- Intl 国际化
- module 模块
- module/cjs CommonJS 模块
- module/esm ECMAScript 模块
- module/package 包模块
- net 网络
- os 操作系统
- path 路径
- perf_hooks 性能钩子
- permission 权限
- process 进程
- punycode 域名代码
- querystring 查询字符串
- readline 逐行读取
- repl 交互式解释器
- report 诊断报告
- stream 流
- stream/web 网络流
- string_decoder 字符串解码器
- test 测试
- timers 定时器
- tls 安全传输层
- trace_events 跟踪事件
- tty 终端
- url 网址
- util 实用工具
- v8 引擎
- vm 虚拟机
- wasi 网络汇编系统接口
- worker_threads 工作线程
- zlib 压缩
- 其他版本
Zlib#
¥Stability: 2 - Stable
源代码: lib/zlib.js
node:zlib
模块提供了使用 Gzip、Deflate/Inflate、以及 Brotli 实现的压缩功能。
¥The node:zlib
module provides compression functionality implemented using
Gzip, Deflate/Inflate, and Brotli.
要访问它:
¥To access it:
const zlib = require('node:zlib');
压缩和解压缩是围绕 Node.js 流 API 构建的。
¥Compression and decompression are built around the Node.js Streams API.
压缩或解压缩流(例如文件)可以通过将源流通过 zlib
Transform
流管道传输到目标流来完成:
¥Compressing or decompressing a stream (such as a file) can be accomplished by
piping the source stream through a zlib
Transform
stream into a destination
stream:
const { createGzip } = require('node:zlib');
const { pipeline } = require('node:stream');
const {
createReadStream,
createWriteStream
} = require('node:fs');
const gzip = createGzip();
const source = createReadStream('input.txt');
const destination = createWriteStream('input.txt.gz');
pipeline(source, gzip, destination, (err) => {
if (err) {
console.error('An error occurred:', err);
process.exitCode = 1;
}
});
// Or, Promisified
const { promisify } = require('node:util');
const pipe = promisify(pipeline);
async function do_gzip(input, output) {
const gzip = createGzip();
const source = createReadStream(input);
const destination = createWriteStream(output);
await pipe(source, gzip, destination);
}
do_gzip('input.txt', 'input.txt.gz')
.catch((err) => {
console.error('An error occurred:', err);
process.exitCode = 1;
});
也可以一步压缩或解压缩数据:
¥It is also possible to compress or decompress data in a single step:
const { deflate, unzip } = require('node:zlib');
const input = '.................................';
deflate(input, (err, buffer) => {
if (err) {
console.error('An error occurred:', err);
process.exitCode = 1;
}
console.log(buffer.toString('base64'));
});
const buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64');
unzip(buffer, (err, buffer) => {
if (err) {
console.error('An error occurred:', err);
process.exitCode = 1;
}
console.log(buffer.toString());
});
// Or, Promisified
const { promisify } = require('node:util');
const do_unzip = promisify(unzip);
do_unzip(buffer)
.then((buf) => console.log(buf.toString()))
.catch((err) => {
console.error('An error occurred:', err);
process.exitCode = 1;
});
线程池使用和性能注意事项#
¥Threadpool usage and performance considerations
所有 zlib
API,除了那些显式同步的 API,都使用 Node.js 内部线程池。这可能会在某些应用中导致令人惊讶的效果和性能限制。
¥All zlib
APIs, except those that are explicitly synchronous, use the Node.js
internal threadpool. This can lead to surprising effects and performance
limitations in some applications.
同时创建和使用大量压缩对象会导致显着的内存碎片。
¥Creating and using a large number of zlib objects simultaneously can cause significant memory fragmentation.
const zlib = require('node:zlib');
const payload = Buffer.from('This is some data');
// WARNING: DO NOT DO THIS!
for (let i = 0; i < 30000; ++i) {
zlib.deflate(payload, (err, buffer) => {});
}
在前面的示例中,同时创建了 30,000 个 deflate 实例。由于某些操作系统如何处理内存分配和释放,这可能会导致严重的内存碎片。
¥In the preceding example, 30,000 deflate instances are created concurrently. Because of how some operating systems handle memory allocation and deallocation, this may lead to significant memory fragmentation.
强烈建议缓存压缩操作的结果以避免重复工作。
¥It is strongly recommended that the results of compression operations be cached to avoid duplication of effort.
压缩 HTTP 请求和响应#
¥Compressing HTTP requests and responses
node:zlib
模块可用于实现对 HTTP 定义的 gzip
、deflate
和 br
内容编码机制的支持。
¥The node:zlib
module can be used to implement support for the gzip
, deflate
and br
content-encoding mechanisms defined by
HTTP.
HTTP Accept-Encoding
标头在 HTTP 请求中用于识别客户端接受的压缩编码。Content-Encoding
标头用于标识实际应用于消息的压缩编码。
¥The HTTP Accept-Encoding
header is used within an HTTP request to identify
the compression encodings accepted by the client. The Content-Encoding
header is used to identify the compression encodings actually applied to a
message.
下面给出的示例经过彻底简化以显示基本概念。使用 zlib
编码可能很昂贵,结果应该被缓存。有关 zlib
使用中涉及的速度/内存/压缩权衡的更多信息,请参阅 内存使用调整。
¥The examples given below are drastically simplified to show the basic concept.
Using zlib
encoding can be expensive, and the results ought to be cached.
See Memory usage tuning for more information on the speed/memory/compression
tradeoffs involved in zlib
usage.
// Client request example
const zlib = require('node:zlib');
const http = require('node:http');
const fs = require('node:fs');
const { pipeline } = require('node:stream');
const request = http.get({ host: 'example.com',
path: '/',
port: 80,
headers: { 'Accept-Encoding': 'br,gzip,deflate' } });
request.on('response', (response) => {
const output = fs.createWriteStream('example.com_index.html');
const onError = (err) => {
if (err) {
console.error('An error occurred:', err);
process.exitCode = 1;
}
};
switch (response.headers['content-encoding']) {
case 'br':
pipeline(response, zlib.createBrotliDecompress(), output, onError);
break;
// Or, just use zlib.createUnzip() to handle both of the following cases:
case 'gzip':
pipeline(response, zlib.createGunzip(), output, onError);
break;
case 'deflate':
pipeline(response, zlib.createInflate(), output, onError);
break;
default:
pipeline(response, output, onError);
break;
}
});
// server example
// Running a gzip operation on every request is quite expensive.
// It would be much more efficient to cache the compressed buffer.
const zlib = require('node:zlib');
const http = require('node:http');
const fs = require('node:fs');
const { pipeline } = require('node:stream');
http.createServer((request, response) => {
const raw = fs.createReadStream('index.html');
// Store both a compressed and an uncompressed version of the resource.
response.setHeader('Vary', 'Accept-Encoding');
let acceptEncoding = request.headers['accept-encoding'];
if (!acceptEncoding) {
acceptEncoding = '';
}
const onError = (err) => {
if (err) {
// If an error occurs, there's not much we can do because
// the server has already sent the 200 response code and
// some amount of data has already been sent to the client.
// The best we can do is terminate the response immediately
// and log the error.
response.end();
console.error('An error occurred:', err);
}
};
// Note: This is not a conformant accept-encoding parser.
// See https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3
if (/\bdeflate\b/.test(acceptEncoding)) {
response.writeHead(200, { 'Content-Encoding': 'deflate' });
pipeline(raw, zlib.createDeflate(), response, onError);
} else if (/\bgzip\b/.test(acceptEncoding)) {
response.writeHead(200, { 'Content-Encoding': 'gzip' });
pipeline(raw, zlib.createGzip(), response, onError);
} else if (/\bbr\b/.test(acceptEncoding)) {
response.writeHead(200, { 'Content-Encoding': 'br' });
pipeline(raw, zlib.createBrotliCompress(), response, onError);
} else {
response.writeHead(200, {});
pipeline(raw, response, onError);
}
}).listen(1337);
默认情况下,zlib
方法在解压缩截断数据时会抛出错误。但是,如果已知数据不完整,或者希望仅检查压缩文件的开头,则可以通过更改用于解压缩输入的最后一个块的刷新方法来抑制默认错误处理数据:
¥By default, the zlib
methods will throw an error when decompressing
truncated data. However, if it is known that the data is incomplete, or
the desire is to inspect only the beginning of a compressed file, it is
possible to suppress the default error handling by changing the flushing
method that is used to decompress the last chunk of input data:
// This is a truncated version of the buffer from the above examples
const buffer = Buffer.from('eJzT0yMA', 'base64');
zlib.unzip(
buffer,
// For Brotli, the equivalent is zlib.constants.BROTLI_OPERATION_FLUSH.
{ finishFlush: zlib.constants.Z_SYNC_FLUSH },
(err, buffer) => {
if (err) {
console.error('An error occurred:', err);
process.exitCode = 1;
}
console.log(buffer.toString());
});
这不会改变其他错误抛出情况下的行为,例如当输入数据的格式无效时。使用此方法,将无法确定输入是否提前结束或缺少完整性检查,因此需要手动检查解压结果是否有效。
¥This will not change the behavior in other error-throwing situations, e.g. when the input data has an invalid format. Using this method, it will not be possible to determine whether the input ended prematurely or lacks the integrity checks, making it necessary to manually check that the decompressed result is valid.
内存使用调整#
¥Memory usage tuning
对于基于 zlib 的流#
¥For zlib-based streams
从 zlib/zconf.h
开始,针对 Node.js 使用进行了修改:
¥From zlib/zconf.h
, modified for Node.js usage:
deflate 的内存要求是(以字节为单位):
¥The memory requirements for deflate are (in bytes):
(1 << (windowBits + 2)) + (1 << (memLevel + 9))
那是:windowBits
的 128K = 15 + memLevel
的 128K = 8(默认值)加上小对象的几千字节。
¥That is: 128K for windowBits
= 15 + 128K for memLevel
= 8
(default values) plus a few kilobytes for small objects.
例如,要将默认内存要求从 256K 减少到 128K,应将选项设置为:
¥For example, to reduce the default memory requirements from 256K to 128K, the options should be set to:
const options = { windowBits: 14, memLevel: 7 };
然而,这通常会降低压缩性能。
¥This will, however, generally degrade compression.
inflate 的内存要求是(以字节为单位)1 << windowBits
。也就是说,windowBits
的 32K = 15(默认值)加上小对象的几千字节。
¥The memory requirements for inflate are (in bytes) 1 << windowBits
.
That is, 32K for windowBits
= 15 (default value) plus a few kilobytes
for small objects.
这是对大小为 chunkSize
的单个内部输出平板缓冲区的补充,默认为 16K。
¥This is in addition to a single internal output slab buffer of size
chunkSize
, which defaults to 16K.
zlib
压缩的速度受 level
设置的影响最大。更高的级别将导致更好的压缩,但需要更长的时间才能完成。较低的级别将导致较少的压缩,但会更快。
¥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.
一般来说,更大的内存使用选项意味着 Node.js 必须对 zlib
进行更少的调用,因为它能够在每个 write
操作上处理更多的数据。所以,这是影响速度的另一个因素,以内存使用为代价。
¥In general, greater memory usage options will mean that Node.js has to make
fewer calls to zlib
because it will be able to process more data on
each write
operation. So, this is another factor that affects the
speed, at the cost of memory usage.
对于基于 Brotli 的流#
¥For Brotli-based streams
有与基于 Brotli 的流的 zlib 选项等效的选项,尽管这些选项的范围与 zlib 的范围不同:
¥There are equivalents to the zlib options for Brotli-based streams, although these options have different ranges than the zlib ones:
-
zlib 的
level
选项匹配 Brotli 的BROTLI_PARAM_QUALITY
选项。¥zlib's
level
option matches Brotli'sBROTLI_PARAM_QUALITY
option. -
zlib 的
windowBits
选项匹配 Brotli 的BROTLI_PARAM_LGWIN
选项。¥zlib's
windowBits
option matches Brotli'sBROTLI_PARAM_LGWIN
option.
有关 Brotli 特定选项的更多详细信息,请参阅 below。
¥See below for more details on Brotli-specific options.
刷新#
¥Flushing
在压缩流上调用 .flush()
将使 zlib
返回尽可能多的当前输出。这可能以降低压缩质量为代价,但在需要尽快提供数据时非常有用。
¥Calling .flush()
on a compression stream will make zlib
return as much
output as currently possible. This may come at the cost of degraded compression
quality, but can be useful when data needs to be available as soon as possible.
在以下示例中,flush()
用于将压缩的部分 HTTP 响应写入客户端:
¥In the following example, flush()
is used to write a compressed partial
HTTP response to the client:
const zlib = require('node:zlib');
const http = require('node:http');
const { pipeline } = require('node:stream');
http.createServer((request, response) => {
// For the sake of simplicity, the Accept-Encoding checks are omitted.
response.writeHead(200, { 'content-encoding': 'gzip' });
const output = zlib.createGzip();
let i;
pipeline(output, response, (err) => {
if (err) {
// If an error occurs, there's not much we can do because
// the server has already sent the 200 response code and
// some amount of data has already been sent to the client.
// The best we can do is terminate the response immediately
// and log the error.
clearInterval(i);
response.end();
console.error('An error occurred:', err);
}
});
i = setInterval(() => {
output.write(`The current time is ${Date()}\n`, () => {
// The data has been passed to zlib, but the compression algorithm may
// have decided to buffer the data for more efficient compression.
// Calling .flush() will make the data available as soon as the client
// is ready to receive it.
output.flush();
});
}, 1000);
}).listen(1337);
常量#
¥Constants
zlib 常量#
¥zlib constants
zlib.h
中定义的所有常量也在 require('node:zlib').constants
上定义。在正常的操作过程中,没有必要使用这些常量。它们被记录在案,因此它们的存在不足为奇。本节几乎直接取自 zlib 文档。
¥All of the constants defined in zlib.h
are also defined on
require('node:zlib').constants
. In the normal course of operations, it will
not be necessary to use these constants. They are documented so that their
presence is not surprising. This section is taken almost directly from the
zlib documentation.
以前,常量可直接从 require('node:zlib')
获得,例如 zlib.Z_NO_FLUSH
。目前仍然可以直接从模块访问常量,但已弃用。
¥Previously, the constants were available directly from require('node:zlib')
,
for instance zlib.Z_NO_FLUSH
. Accessing the constants directly from the module
is currently still possible but is deprecated.
允许的刷新值。
¥Allowed flush values.
-
zlib.constants.Z_NO_FLUSH
-
zlib.constants.Z_PARTIAL_FLUSH
-
zlib.constants.Z_SYNC_FLUSH
-
zlib.constants.Z_FULL_FLUSH
-
zlib.constants.Z_FINISH
-
zlib.constants.Z_BLOCK
-
zlib.constants.Z_TREES
压缩/解压缩函数的返回代码。负值是错误,正值用于特殊但正常的事件。
¥Return codes for the compression/decompression functions. Negative values are errors, positive values are used for special but normal events.
-
zlib.constants.Z_OK
-
zlib.constants.Z_STREAM_END
-
zlib.constants.Z_NEED_DICT
-
zlib.constants.Z_ERRNO
-
zlib.constants.Z_STREAM_ERROR
-
zlib.constants.Z_DATA_ERROR
-
zlib.constants.Z_MEM_ERROR
-
zlib.constants.Z_BUF_ERROR
-
zlib.constants.Z_VERSION_ERROR
压缩级别。
¥Compression levels.
-
zlib.constants.Z_NO_COMPRESSION
-
zlib.constants.Z_BEST_SPEED
-
zlib.constants.Z_BEST_COMPRESSION
-
zlib.constants.Z_DEFAULT_COMPRESSION
压缩策略。
¥Compression strategy.
-
zlib.constants.Z_FILTERED
-
zlib.constants.Z_HUFFMAN_ONLY
-
zlib.constants.Z_RLE
-
zlib.constants.Z_FIXED
-
zlib.constants.Z_DEFAULT_STRATEGY
Brotli 常量#
¥Brotli constants
有几个选项和其他常量可用于基于 Brotli 的流:
¥There are several options and other constants available for Brotli-based streams:
刷新操作#
¥Flush operations
以下值是基于 Brotli 的流的有效刷新操作:
¥The following values are valid flush operations for Brotli-based streams:
-
zlib.constants.BROTLI_OPERATION_PROCESS
(所有操作的默认值)¥
zlib.constants.BROTLI_OPERATION_PROCESS
(default for all operations) -
zlib.constants.BROTLI_OPERATION_FLUSH
(调用.flush()
时默认)¥
zlib.constants.BROTLI_OPERATION_FLUSH
(default when calling.flush()
) -
zlib.constants.BROTLI_OPERATION_FINISH
(最后一个块的默认值)¥
zlib.constants.BROTLI_OPERATION_FINISH
(default for the last chunk) -
zlib.constants.BROTLI_OPERATION_EMIT_METADATA
-
这个特定的操作可能很难在 Node.js 上下文中使用,因为流层很难知道哪些数据会在这个帧中结束。此外,目前无法通过 Node.js API 使用这些数据。
¥This particular operation may be hard to use in a Node.js context, as the streaming layer makes it hard to know which data will end up in this frame. Also, there is currently no way to consume this data through the Node.js API.
-
压缩器选项#
¥Compressor options
可以在 Brotli 编码器上设置几个选项,影响压缩效率和速度。键和值都可以作为 zlib.constants
对象的属性访问。
¥There are several options that can be set on Brotli encoders, affecting
compression efficiency and speed. Both the keys and the values can be accessed
as properties of the zlib.constants
object.
最重要的选项是:
¥The most important options are:
-
BROTLI_PARAM_MODE
-
BROTLI_MODE_GENERIC
(默认)¥
BROTLI_MODE_GENERIC
(default) -
BROTLI_MODE_TEXT
,针对 UTF-8 文本进行了调整¥
BROTLI_MODE_TEXT
, adjusted for UTF-8 text -
BROTLI_MODE_FONT
,针对 WOFF 2.0 字体进行了调整¥
BROTLI_MODE_FONT
, adjusted for WOFF 2.0 fonts
-
-
BROTLI_PARAM_QUALITY
-
范围从
BROTLI_MIN_QUALITY
到BROTLI_MAX_QUALITY
,默认为BROTLI_DEFAULT_QUALITY
。¥Ranges from
BROTLI_MIN_QUALITY
toBROTLI_MAX_QUALITY
, with a default ofBROTLI_DEFAULT_QUALITY
.
-
-
BROTLI_PARAM_SIZE_HINT
-
表示预期输入大小的整数值;对于未知的输入大小,默认为
0
。¥Integer value representing the expected input size; defaults to
0
for an unknown input size.
-
可以设置以下标志以对压缩算法和内存使用调整进行高级控制:
¥The following flags can be set for advanced control over the compression algorithm and memory usage tuning:
-
BROTLI_PARAM_LGWIN
-
范围从
BROTLI_MIN_WINDOW_BITS
到BROTLI_MAX_WINDOW_BITS
,默认为BROTLI_DEFAULT_WINDOW
,如果设置了BROTLI_PARAM_LARGE_WINDOW
标志,则最高可达BROTLI_LARGE_MAX_WINDOW_BITS
。¥Ranges from
BROTLI_MIN_WINDOW_BITS
toBROTLI_MAX_WINDOW_BITS
, with a default ofBROTLI_DEFAULT_WINDOW
, or up toBROTLI_LARGE_MAX_WINDOW_BITS
if theBROTLI_PARAM_LARGE_WINDOW
flag is set.
-
-
BROTLI_PARAM_LGBLOCK
-
范围从
BROTLI_MIN_INPUT_BLOCK_BITS
到BROTLI_MAX_INPUT_BLOCK_BITS
。¥Ranges from
BROTLI_MIN_INPUT_BLOCK_BITS
toBROTLI_MAX_INPUT_BLOCK_BITS
.
-
-
BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING
-
降低压缩率以提高解压速度的布尔标志。
¥Boolean flag that decreases compression ratio in favour of decompression speed.
-
-
BROTLI_PARAM_LARGE_WINDOW
-
BROTLI_PARAM_NPOSTFIX
-
范围从
0
到BROTLI_MAX_NPOSTFIX
。¥Ranges from
0
toBROTLI_MAX_NPOSTFIX
.
-
-
BROTLI_PARAM_NDIRECT
-
范围从
0
到15 << NPOSTFIX
,步长为1 << NPOSTFIX
。¥Ranges from
0
to15 << NPOSTFIX
in steps of1 << NPOSTFIX
.
-
解压选项#
¥Decompressor options
这些高级选项可用于控制减压:
¥These advanced options are available for controlling decompression:
-
BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION
-
影响内部内存分配模式的布尔标志。
¥Boolean flag that affects internal memory allocation patterns.
-
-
BROTLI_DECODER_PARAM_LARGE_WINDOW
类:Options
#
¥Class: Options
每个基于 zlib 的类都有一个 options
对象。不需要任何选项。
¥Each zlib-based class takes an options
object. No options are required.
某些选项仅在压缩时相关,而被解压缩类忽略。
¥Some options are only relevant when compressing and are ignored by the decompression classes.
-
flush
<integer> 默认值:zlib.constants.Z_NO_FLUSH
¥
flush
<integer> Default:zlib.constants.Z_NO_FLUSH
-
finishFlush
<integer> 默认值:zlib.constants.Z_FINISH
¥
finishFlush
<integer> Default:zlib.constants.Z_FINISH
-
chunkSize
<integer> 默认值:16 * 1024
¥
chunkSize
<integer> Default:16 * 1024
-
windowBits
<integer> -
level
<integer> (仅压缩)¥
level
<integer> (compression only) -
memLevel
<integer> (仅压缩)¥
memLevel
<integer> (compression only) -
strategy
<integer> (仅压缩)¥
strategy
<integer> (compression only) -
dictionary
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> (仅 deflate/inflate,默认为空字典)¥
dictionary
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> (deflate/inflate only, empty dictionary by default) -
info
<boolean> (如果是true
,则返回带有buffer
和engine
的对象。)¥
info
<boolean> (Iftrue
, returns an object withbuffer
andengine
.) -
maxOutputLength
<integer> 使用 方便的方法 时限制输出大小。默认值:buffer.kMaxLength
¥
maxOutputLength
<integer> Limits output size when using convenience methods. Default:buffer.kMaxLength
有关更多信息,请参阅 deflateInit2
和 inflateInit2
文档。
¥See the deflateInit2
and inflateInit2
documentation for more
information.
类:BrotliOptions
#
¥Class: BrotliOptions
每个基于 Brotli 的类都有一个 options
对象。所有选项都是可选的。
¥Each Brotli-based class takes an options
object. All options are optional.
-
flush
<integer> 默认值:zlib.constants.BROTLI_OPERATION_PROCESS
¥
flush
<integer> Default:zlib.constants.BROTLI_OPERATION_PROCESS
-
finishFlush
<integer> 默认值:zlib.constants.BROTLI_OPERATION_FINISH
¥
finishFlush
<integer> Default:zlib.constants.BROTLI_OPERATION_FINISH
-
chunkSize
<integer> 默认值:16 * 1024
¥
chunkSize
<integer> Default:16 * 1024
-
params
<Object> 包含索引 Brotli 参数 的键值对象。¥
params
<Object> Key-value object containing indexed Brotli parameters. -
maxOutputLength
<integer> 使用 方便的方法 时限制输出大小。默认值:buffer.kMaxLength
¥
maxOutputLength
<integer> Limits output size when using convenience methods. Default:buffer.kMaxLength
例如:
¥For example:
const stream = zlib.createBrotliCompress({
chunkSize: 32 * 1024,
params: {
[zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
[zlib.constants.BROTLI_PARAM_QUALITY]: 4,
[zlib.constants.BROTLI_PARAM_SIZE_HINT]: fs.statSync(inputFile).size
}
});
类:zlib.BrotliCompress
#
¥Class: zlib.BrotliCompress
使用 Brotli 算法压缩数据。
¥Compress data using the Brotli algorithm.
类:zlib.BrotliDecompress
#
¥Class: zlib.BrotliDecompress
使用 Brotli 算法解压缩数据。
¥Decompress data using the Brotli algorithm.
类:zlib.Deflate
#
¥Class: zlib.Deflate
使用 deflate 压缩数据。
¥Compress data using deflate.
类:zlib.DeflateRaw
#
¥Class: zlib.DeflateRaw
使用 deflate 压缩数据,并且不附加 zlib
标头。
¥Compress data using deflate, and do not append a zlib
header.
类:zlib.Gunzip
#
¥Class: zlib.Gunzip
解压缩 gzip 流。
¥Decompress a gzip stream.
类:zlib.Gzip
#
¥Class: zlib.Gzip
使用 gzip 压缩数据。
¥Compress data using gzip.
类:zlib.Inflate
#
¥Class: zlib.Inflate
解压缩 deflate 流。
¥Decompress a deflate stream.
类:zlib.InflateRaw
#
¥Class: zlib.InflateRaw
解压缩原始的 deflate 流。
¥Decompress a raw deflate stream.
类:zlib.Unzip
#
¥Class: zlib.Unzip
通过自动检测标头来解压缩 Gzip 或 Deflate 压缩的流。
¥Decompress either a Gzip- or Deflate-compressed stream by auto-detecting the header.
类:zlib.ZlibBase
#
¥Class: zlib.ZlibBase
不是由 node:zlib
模块导出的。它记录在此处,因为它是压缩器/解压缩器类的基类。
¥Not exported by the node:zlib
module. It is documented here because it is the
base class of the compressor/decompressor classes.
这个类继承自 stream.Transform
,允许在管道和类似的流操作中使用 node:zlib
对象。
¥This class inherits from stream.Transform
, allowing node:zlib
objects to
be used in pipes and similar stream operations.
zlib.bytesRead
#
弃用的 zlib.bytesWritten
别名。选择这个原始名称是因为将值解释为引擎读取的字节数也是有意义的,但与 Node.js 中以这些名称公开值的其他流不一致。
¥Deprecated alias for zlib.bytesWritten
. This original name was chosen
because it also made sense to interpret the value as the number of bytes
read by the engine, but is inconsistent with other streams in Node.js that
expose values under these names.
zlib.bytesWritten
#
zlib.bytesWritten
属性指定在处理字节(压缩或解压缩,视派生类而定)之前写入引擎的字节数。
¥The zlib.bytesWritten
property specifies the number of bytes written to
the engine, before the bytes are processed (compressed or decompressed,
as appropriate for the derived class).
zlib.close([callback])
#
callback
<Function>
关闭底层句柄。
¥Close the underlying handle.
zlib.flush([kind, ]callback)
#
-
kind
默认值:zlib.constants.Z_FULL_FLUSH
用于基于 zlib 的流,zlib.constants.BROTLI_OPERATION_FLUSH
用于基于 Brotli 的流。¥
kind
Default:zlib.constants.Z_FULL_FLUSH
for zlib-based streams,zlib.constants.BROTLI_OPERATION_FLUSH
for Brotli-based streams. -
callback
<Function>
刷新挂起的数据。不要轻率地称之为,过早刷新会对压缩算法的有效性产生负面影响。
¥Flush pending data. Don't call this frivolously, premature flushes negatively impact the effectiveness of the compression algorithm.
调用它只会从内部 zlib
状态刷新数据,并且不会在流级别执行任何类型的刷新。相反,它的行为类似于对 .write()
的正常调用,即它将排队等待其他未决写入,并且仅在从流中读取数据时才产生输出。
¥Calling this only flushes data from the internal zlib
state, and does not
perform flushing of any kind on the streams level. Rather, it behaves like a
normal call to .write()
, i.e. it will be queued up behind other pending
writes and will only produce output when data is being read from the stream.
zlib.params(level, strategy, callback)
#
-
level
<integer> -
strategy
<integer> -
callback
<Function>
此函数仅适用于基于 zlib 的流,即不适用于 Brotli。
¥This function is only available for zlib-based streams, i.e. not Brotli.
动态更新压缩级别和压缩策略。仅适用于 deflate 算法。
¥Dynamically update the compression level and compression strategy. Only applicable to deflate algorithm.
zlib.reset()
#
将压缩器/解压缩器重置为出厂默认设置。仅适用于 inflate 和 deflate 算法。
¥Reset the compressor/decompressor to factory defaults. Only applicable to the inflate and deflate algorithms.
zlib.constants
#
提供枚举 Zlib 相关常量的对象。
¥Provides an object enumerating Zlib-related constants.
zlib.createBrotliCompress([options])
#
options
<brotli options>
创建并返回新的 BrotliCompress
对象。
¥Creates and returns a new BrotliCompress
object.
zlib.createBrotliDecompress([options])
#
options
<brotli options>
创建并返回新的 BrotliDecompress
对象。
¥Creates and returns a new BrotliDecompress
object.
zlib.createDeflate([options])
#
options
<zlib options>
创建并返回新的 Deflate
对象。
¥Creates and returns a new Deflate
object.
zlib.createDeflateRaw([options])
#
options
<zlib options>
创建并返回新的 DeflateRaw
对象。
¥Creates and returns a new DeflateRaw
object.
当原始 deflate 流的 windowBits
设置为 8 时,zlib 从 1.2.8 到 1.2.11 的升级改变了行为。如果最初设置为 8,则 zlib 会自动将 windowBits
设置为 9。较新版本的 zlib 会抛出异常,因此 Node.js 恢复了将值从 8 升级到 9 的原始行为,因为将 windowBits = 9
传给 zlib 实际上会产生一个仅有效使用 8 位窗口的压缩流。
¥An upgrade of zlib from 1.2.8 to 1.2.11 changed behavior when windowBits
is set to 8 for raw deflate streams. zlib would automatically set windowBits
to 9 if was initially set to 8. Newer versions of zlib will throw an exception,
so Node.js restored the original behavior of upgrading a value of 8 to 9,
since passing windowBits = 9
to zlib actually results in a compressed stream
that effectively uses an 8-bit window only.
zlib.createGunzip([options])
#
options
<zlib options>
创建并返回新的 Gunzip
对象。
¥Creates and returns a new Gunzip
object.
zlib.createGzip([options])
#
options
<zlib options>
zlib.createInflate([options])
#
options
<zlib options>
创建并返回新的 Inflate
对象。
¥Creates and returns a new Inflate
object.
zlib.createInflateRaw([options])
#
options
<zlib options>
创建并返回新的 InflateRaw
对象。
¥Creates and returns a new InflateRaw
object.
zlib.createUnzip([options])
#
options
<zlib options>
创建并返回新的 Unzip
对象。
¥Creates and returns a new Unzip
object.
便捷方法#
¥Convenience methods
所有这些都将 Buffer
、TypedArray
、DataView
、ArrayBuffer
或字符串作为第一个参数,可选的第二个参数为 zlib
类提供选项,并将使用 callback(error, result)
调用提供的回调。
¥All of these take a Buffer
, TypedArray
, DataView
,
ArrayBuffer
or string 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)
.
每个方法都有一个对应的 *Sync
方法,它们接受相同的参数,但没有回调。
¥Every method has a *Sync
counterpart, which accept the same arguments, but
without a callback.
zlib.brotliCompress(buffer[, options], callback)
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<brotli options> -
callback
<Function>
zlib.brotliCompressSync(buffer[, options])
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<brotli options>
使用 BrotliCompress
压缩数据块。
¥Compress a chunk of data with BrotliCompress
.
zlib.brotliDecompress(buffer[, options], callback)
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<brotli options> -
callback
<Function>
zlib.brotliDecompressSync(buffer[, options])
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<brotli options>
使用 BrotliDecompress
解压缩数据块。
¥Decompress a chunk of data with BrotliDecompress
.
zlib.deflate(buffer[, options], callback)
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options> -
callback
<Function>
zlib.deflateSync(buffer[, options])
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options>
使用 Deflate
压缩数据块。
¥Compress a chunk of data with Deflate
.
zlib.deflateRaw(buffer[, options], callback)
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options> -
callback
<Function>
zlib.deflateRawSync(buffer[, options])
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options>
使用 DeflateRaw
压缩数据块。
¥Compress a chunk of data with DeflateRaw
.
zlib.gunzip(buffer[, options], callback)
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options> -
callback
<Function>
zlib.gunzipSync(buffer[, options])
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options>
使用 Gunzip
解压缩数据块。
¥Decompress a chunk of data with Gunzip
.
zlib.gzip(buffer[, options], callback)
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options> -
callback
<Function>
zlib.gzipSync(buffer[, options])
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options>
使用 Gzip
压缩数据块。
¥Compress a chunk of data with Gzip
.
zlib.inflate(buffer[, options], callback)
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options> -
callback
<Function>
zlib.inflateSync(buffer[, options])
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options>
使用 Inflate
解压缩数据块。
¥Decompress a chunk of data with Inflate
.
zlib.inflateRaw(buffer[, options], callback)
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options> -
callback
<Function>
zlib.inflateRawSync(buffer[, options])
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options>
使用 InflateRaw
解压缩数据块。
¥Decompress a chunk of data with InflateRaw
.
zlib.unzip(buffer[, options], callback)
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options> -
callback
<Function>
zlib.unzipSync(buffer[, options])
#
-
buffer
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string> -
options
<zlib options>
使用 Unzip
解压缩数据块。
¥Decompress a chunk of data with Unzip
.