Использование пула потоков и соображения по производительности

Все zlib API, за исключением явных синхронных, используют внутренний пул потоков Node.js. Это может приводить к неожиданным последствиям и ограничениям производительности в некоторых приложениях.

Создание и одновременное использование большого числа объектов zlib может привести к существенной фрагментации памяти.

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) => {});
} copy

В приведенном примере одновременно создаётся 30 000 экземпляров deflate. Из-за того, как некоторые операционные системы обрабатывают выделение и освобождение памяти, это может привести к существенной фрагментации памяти.

Сильно рекомендуется кешировать результаты операций сжатия, чтобы избежать дублирования усилий.

Сжатие HTTP-запросов и ответов

Модуль node:zlib может использоваться для реализации поддержки механизмов кодирования содержимого gzip, deflate и br, определённых в HTTP.

Заголовок HTTP Accept-Encoding используется в HTTP-запросе для указания кодировок сжатия, поддерживаемых клиентом. Заголовок Content-Encoding используется для указания фактически применённых кодировок сжатия к сообщению.

Нижеприведённые примеры сильно упрощены, чтобы продемонстрировать базовый принцип. Использование кодирования zlib может быть дорогостоящим, и результаты следует кешировать. Подробнее о компромиссах между скоростью, памятью и степенью сжатия при использовании zlib см. в разделе Настройка использования памяти.

// 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;
  }
}); copy

// 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); copy

По умолчанию методы zlib будут генерировать ошибку при распаковке усечённых данных. Однако, если известно, что данные неполные, или требуется просмотреть только начало сжатого файла, можно подавить обработку ошибок по умолчанию, изменив метод сброса для распаковки последнего фрагмента входных данных:

// 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());
  }); copy

Это не изменит поведение в других ситуациях, порождающих ошибки, например, при неверном формате входных данных. Используя этот метод, нельзя определить, закончились ли данные преждевременно или им не хватает проверок целостности, поэтому необходимо вручную проверить, что результат распаковки корректен.

Настройка использования памяти

Для потоков, основанных на zlib

Из zlib/zconf.h, модифицировано для использования в Node.js:

Требования к памяти для deflate (в байтах):

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

То есть: 128 КБ для windowBits = 15 + 128 КБ для memLevel = 8 (значения по умолчанию) плюс несколько килобайт для небольших объектов.

Например, чтобы уменьшить значения памяти по умолчанию с 256 КБ до 128 КБ, необходимо установить следующие параметры:

const options = { windowBits: 14, memLevel: 7 }; copy

Однако это, как правило, ухудшает степень сжатия.

Требования к памяти для inflate (в байтах) 1 << windowBits. То есть 32 КБ для windowBits = 15 (значение по умолчанию) плюс несколько килобайт для небольших объектов.

Это помимо одного внутреннего буфера выходного фрагмента размером chunkSize, который по умолчанию равен 16 КБ.

Скорость сжатия zlib наиболее сильно зависит от параметра level. Более высокое значение приведёт к лучшему сжатию, но потребует больше времени. Более низкое значение приведёт к меньшему сжатию, но будет значительно быстрее.

В целом, более высокие параметры использования памяти означают, что Node.js будет делать меньше вызовов zlib, поскольку сможет обрабатывать больше данных в каждой write операции. Таким образом, это ещё один фактор, влияющий на скорость, за счёт увеличения использования памяти.

Для потоков, основанных на Brotli

Существуют аналоги zlib-параметров для потоков, основанных на Brotli, хотя эти параметры имеют другие диапазоны, чем zlib-параметры:

• Параметр zlib level соответствует параметру Brotli BROTLI_PARAM_QUALITY.
• Параметр zlib windowBits соответствует параметру Brotli BROTLI_PARAM_LGWIN.

Подробнее о Brotli-специфичных параметрах см. ниже в разделе константы Brotli.

Сброс

Вызов .flush() на потоке сжатия заставит zlib вернуть как можно больше выходных данных в данный момент. Это может привести к ухудшению качества сжатия, но может быть полезно, когда данные необходимо предоставить как можно быстрее.

В следующем примере используется flush() для записи сжатого частичного HTTP-ответа клиенту:

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); copy

Константы

Константы zlib

Все константы, определённые в zlib.h, также определены в require('node:zlib').constants. В обычном ходе работы использование этих констант не требуется. Они документированы, чтобы их присутствие не вызвало неожиданностей. Этот раздел взят почти напрямую из документации zlib.

Ранее константы были доступны непосредственно из require('node:zlib'), например zlib.Z_NO_FLUSH. Доступ к константам непосредственно из модуля всё ещё возможен, но устарел.

Допустимые значения сброса.

• 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

Коды возврата для функций сжатия/распаковки. Отрицательные значения — ошибки, положительные значения используются для специальных, но нормальных событий.

• 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

Уровни сжатия.

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

Стратегия сжатия.

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

Константы Brotli

Существует несколько параметров и других констант, доступных для потоков, основанных на Brotli:

Операции сброса

Следующие значения являются допустимыми операциями сброса для потоков, основанных на Brotli:

• zlib.constants.BROTLI_OPERATION_PROCESS (значение по умолчанию для всех операций)
• zlib.constants.BROTLI_OPERATION_FLUSH (значение по умолчанию при вызове .flush())
• zlib.constants.BROTLI_OPERATION_FINISH (значение по умолчанию для последнего фрагмента)
• zlib.constants.BROTLI_OPERATION_EMIT_METADATA
  • Эта конкретная операция может быть трудной для использования в контексте Node.js, так как уровень потоков затрудняет понимание, какие данные попадут в этот кадр. Также в настоящее время нет способа получить доступ к этим данным через Node.js API.

Параметры сжатия

Есть несколько параметров, которые можно установить для Brotli-кодировщиков, влияющих на эффективность и скорость сжатия. И ключи, и значения доступны как свойства объекта zlib.constants.

Наиболее важные параметры:

• BROTLI_PARAM_MODE
  • BROTLI_MODE_GENERIC (значение по умолчанию)
  • BROTLI_MODE_TEXT, скорректировано для UTF-8 текста
  • BROTLI_MODE_FONT, скорректировано для шрифтов WOFF 2.0
• BROTLI_PARAM_QUALITY
  • Диапазон от BROTLI_MIN_QUALITY до BROTLI_MAX_QUALITY, со значением по умолчанию BROTLI_DEFAULT_QUALITY.
• BROTLI_PARAM_SIZE_HINT
  • Целое число, представляющее ожидаемый размер входных данных; по умолчанию 0 для неизвестного размера входных данных.

Следующие флаги могут быть установлены для расширенного управления алгоритмом сжатия и настройкой использования памяти:

• BROTLI_PARAM_LGWIN
  • Диапазон от BROTLI_MIN_WINDOW_BITS до BROTLI_MAX_WINDOW_BITS, со значением по умолчанию BROTLI_DEFAULT_WINDOW, или до BROTLI_LARGE_MAX_WINDOW_BITS если установлен флаг BROTLI_PARAM_LARGE_WINDOW.
• BROTLI_PARAM_LGBLOCK
  • Диапазон от BROTLI_MIN_INPUT_BLOCK_BITS до BROTLI_MAX_INPUT_BLOCK_BITS.
• BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING
  • Логический флаг, который уменьшает коэффициент сжатия в пользу скорости распаковки.
• BROTLI_PARAM_LARGE_WINDOW
  • Логический флаг, активирующий режим «Large Window Brotli» (несовместимый с форматом Brotli, стандартизованным в RFC 7932).
• BROTLI_PARAM_NPOSTFIX
  • Диапазон от 0 до BROTLI_MAX_NPOSTFIX.
• BROTLI_PARAM_NDIRECT
  • Диапазон от 0 до 15 << NPOSTFIX с шагом 1 << NPOSTFIX.

Параметры распаковки

Эти расширенные параметры доступны для управления распаковкой:

• BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION
  • Логический флаг, влияющий на внутренние схемы распределения памяти.
• BROTLI_DECODER_PARAM_LARGE_WINDOW
  • Логический флаг, активирующий режим «Large Window Brotli» (несовместимый с форматом Brotli, стандартизованным в RFC 7932).

Класс: Options

Каждый класс, основанный на zlib, принимает объект options. Опции не требуются.

Некоторые опции актуальны только при сжатии и игнорируются классами для распаковки.

• flush <целое число> По умолчанию: zlib.constants.Z_NO_FLUSH
• finishFlush <целое число> По умолчанию: zlib.constants.Z_FINISH
• chunkSize <целое число> По умолчанию: 16 * 1024
• windowBits <целое число>
• level <целое число> (только для сжатия)
• memLevel <целое число> (только для сжатия)
• strategy <целое число> (только для сжатия)
• dictionary <Буфер> | <Массив типов> | <DataView> | <ArrayBuffer> (только для deflate/inflate, пустой словарь по умолчанию)
• info <логическое значение> (Если true, возвращает объект с buffer и engine.)
• maxOutputLength <целое число> Ограничивает размер вывода при использовании методов по умолчанию. По умолчанию: buffer.kMaxLength

См. документацию deflateInit2 и inflateInit2 для получения дополнительной информации.

Класс: BrotliOptions

Каждый класс, основанный на Brotli, принимает объект options. Все опции необязательны.

• flush <целое число> По умолчанию: zlib.constants.BROTLI_OPERATION_PROCESS
• finishFlush <целое число> По умолчанию: zlib.constants.BROTLI_OPERATION_FINISH
• chunkSize <целое число> По умолчанию: 16 * 1024
• params <Объект> Объект пар ключ-значение, содержащий индексированные параметры Brotli.
• maxOutputLength <целое число> Ограничивает размер вывода при использовании методов по умолчанию. По умолчанию: buffer.kMaxLength

Например:

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,
  },
}); copy

Класс: zlib.BrotliCompress

Сжимает данные с помощью алгоритма Brotli.

Класс: zlib.BrotliDecompress

Распаковывает данные с помощью алгоритма Brotli.

Класс: zlib.Deflate

Сжимает данные с помощью deflate.

Класс: zlib.DeflateRaw

Сжимает данные с помощью deflate, не добавляя заголовок zlib.

Класс: zlib.Gunzip

Распаковывает поток gzip.

Класс: zlib.Gzip

Сжимает данные с помощью gzip.

Класс: zlib.Inflate

Распаковывает поток deflate.

Класс: zlib.InflateRaw

Распаковывает поток raw deflate.

Класс: zlib.Unzip

Распаковывает поток, сжатый gzip или deflate, автоматически определяя заголовок.

Класс: zlib.ZlibBase

Не экспортируется модулем node:zlib. Он документирован здесь, потому что является базовым классом для классов сжатия/распаковки.

Этот класс наследуется от stream.Transform, что позволяет использовать объекты node:zlib в конвейерах и аналогичных операциях с потоками.

zlib.bytesRead

• <число>

Устаревшее псевдоним для zlib.bytesWritten. Это оригинальное имя было выбрано, потому что также имело смысл интерпретировать значение как количество байт, прочитанных движком, но не соответствует другим потокам в Node.js, которые экспонируют значения под этими именами.

zlib.bytesWritten

• <число>

Свойство zlib.bytesWritten указывает количество байтов, записанных в движок, прежде чем эти байты будут обработаны (сжаты или распакованы, в зависимости от производного класса).

zlib.crc32(data[, value])

• data <строка> | <Буфер> | <Массив типов> | <DataView> Если data является строкой, она будет закодирована в UTF-8 перед использованием для вычислений.
• value <целое число> Необязательное начальное значение. Оно должно быть 32-битным беззнаковым целым числом. По умолчанию: 0
• Возвращает: <целое число> 32-битное беззнаковое целое число, содержащее контрольную сумму.

Вычисляет 32-битную контрольную сумму CRC для data. Если указано value, оно используется в качестве начального значения контрольной суммы; в противном случае используется 0.

Алгоритм CRC разработан для вычисления контрольных сумм и обнаружения ошибок в передаче данных. Он не подходит для криптографической аутентификации.

Для согласованности с другими API, если data — строка, она будет закодирована в UTF-8 перед использованием для вычислений. Если пользователи используют Node.js только для вычисления и проверки контрольных сумм, это работает хорошо с другими API, которые по умолчанию используют кодировку UTF-8.

Некоторые сторонние JavaScript-библиотеки вычисляют контрольную сумму для строки, основываясь на str.charCodeAt(), чтобы их можно было использовать в браузерах. Если пользователям нужно сопоставить контрольную сумму, вычисленную такой библиотекой в браузере, лучше использовать ту же библиотеку в Node.js, если она работает и там. Если пользователям необходимо использовать zlib.crc32() для сопоставления контрольной суммы, созданной такой сторонней библиотекой:

1. Если библиотека принимает Uint8Array в качестве входных данных, используйте TextEncoder в браузере для кодирования строки в Uint8Array с кодировкой UTF-8 и вычислите контрольную сумму на основе закодированной в UTF-8 строки в браузере.
2. Если библиотека принимает только строку и вычисляет данные на основе str.charCodeAt(), в Node.js преобразуйте строку в буфер, используя Buffer.from(str, 'utf16le').

Модули MJS

import zlib from 'node:zlib';
import { Buffer } from 'node:buffer';

let crc = zlib.crc32('hello');  // 907060870
crc = zlib.crc32('world', crc);  // 4192936109

crc = zlib.crc32(Buffer.from('hello', 'utf16le'));  // 1427272415
crc = zlib.crc32(Buffer.from('world', 'utf16le'), crc);  // 4150509955

Модули CJS

const zlib = require('node:zlib');
const { Buffer } = require('node:buffer');

let crc = zlib.crc32('hello');  // 907060870
crc = zlib.crc32('world', crc);  // 4192936109

crc = zlib.crc32(Buffer.from('hello', 'utf16le'));  // 1427272415
crc = zlib.crc32(Buffer.from('world', 'utf16le'), crc);  // 4150509955

zlib.close([callback])

• callback <Функция>

Закрыть базовый дескриптор.

zlib.flush([kind, ]callback)

• kind По умолчанию: zlib.constants.Z_FULL_FLUSH для потоков на основе zlib, zlib.constants.BROTLI_OPERATION_FLUSH для потоков на основе Brotli.
• callback <Функция>

Очистить данные в очереди. Не вызывайте это напрасно; преждевременная очистка негативно сказывается на эффективности алгоритма сжатия.

Вызов этой функции только очищает данные из внутреннего состояния zlib, а не производит очистку на уровне потоков. Вместо этого она ведет себя как обычный вызов .write(), т.е. она будет помещена в очередь позади других ожидающих записей и произведёт вывод только при чтении данных из потока.

zlib.params(level, strategy, callback)

• level <целое число>
• strategy <целое число>
• callback <Функция>

Эта функция доступна только для потоков на основе zlib, то есть не для Brotli.

Динамическое обновление уровня сжатия и стратегии сжатия. Применимо только к алгоритму deflate.

zlib.reset()

Сброс сжатия/распаковки до заводских настроек. Применимо только к алгоритмам inflate и deflate.

zlib.constants

Предоставляет объект, перечисляющий константы, связанные с Zlib.

zlib.createBrotliCompress([options])

• options <параметры Brotli>

Создаёт и возвращает новый объект BrotliCompress.

zlib.createBrotliDecompress([options])

• options <параметры Brotli>

Создаёт и возвращает новый объект BrotliDecompress.

zlib.createDeflate([options])

• options <параметры zlib>

Создаёт и возвращает новый объект Deflate.

zlib.createDeflateRaw([options])

• options <параметры zlib>

Создаёт и возвращает новый объект DeflateRaw.

Обновление zlib с 1.2.8 до 1.2.11 изменило поведение, когда windowBits установлено в 8 для потоков raw deflate. zlib автоматически устанавливает windowBits в 9, если оно изначально было 8. Более новые версии zlib выдают исключение, поэтому Node.js восстановил исходное поведение, повышая значение 8 до 9, поскольку передача windowBits = 9 в zlib фактически приводит к сжатому потоку, который эффективно использует окно размером только 8 бит.

zlib.createGunzip([options])

• options <параметры zlib>

Создаёт и возвращает новый объект Gunzip.

zlib.createGzip([options])

• options <параметры zlib>

Создаёт и возвращает новый объект Gzip. См. пример.

zlib.createInflate([options])

• options <параметры zlib>

Создаёт и возвращает новый объект Inflate.

zlib.createInflateRaw([options])

• options <параметры zlib>

Создаёт и возвращает новый объект InflateRaw.

zlib.createUnzip([options])

• options <параметры zlib>

Создаёт и возвращает новый объект Unzip.

Способе удобной работы

Все они принимают Buffer, TypedArray, DataView, ArrayBuffer или строку в качестве первого аргумента, необязательный второй аргумент для передачи параметров в классы zlib и вызовет переданный обратный вызов с callback(error, result).

Каждый метод имеет *Sync эквивалент, который принимает те же аргументы, но без обратного вызова.

zlib.brotliCompress(buffer[, options], callback)

• buffer <Буфер> | <Массив типов> | <Представление данных> | <Объект буфера> | <строка>
• options <параметры Brotli>
• callback <Функция>

zlib.brotliCompressSync(buffer[, options])

• buffer <Буфер> | <Массив типов> | <Представление данных> | <Объект буфера> | <строка>
• options <параметры Brotli>

Сжать кусок данных с помощью BrotliCompress.

zlib.brotliDecompress(buffer[, options], callback)

• buffer <Буфер> | <Массив типов> | <Представление данных> | <Объект буфера> | <строка>
• options <параметры Brotli>
• callback <Функция>

zlib.brotliDecompressSync(buffer[, options])

• buffer <Буфер> | <Массив типов> | <Представление данных> | <Объект буфера> | <строка>
• options <параметры Brotli>

Распаковать кусок данных с помощью BrotliDecompress.

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

• buffer <Буфер> | <Массив типов> | <Представление данных> | <Объект буфера> | <строка>
• options <параметры zlib>
• callback <Функция>

zlib.deflateSync(buffer[, options])

• buffer <Буфер> | <Массив типов> | <Представление данных> | <Объект буфера> | <строка>
• options <параметры zlib>

Сжать кусок данных с помощью Deflate.

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

• buffer <Буфер> | <Массив типов> | <Представление данных> | <Объект буфера> | <строка>
• options <параметры zlib>
• callback <Функция>

zlib.deflateRawSync(buffer[, options])

• buffer <Буфер> | <Массив типов> | <Представление данных> | <Объект буфера> | <строка>
• options <параметры zlib>

Сжать кусок данных с помощью 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.

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.

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.

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.

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.