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

Все 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 параметрах.

Сброс

Вызов .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, так как уровень потоков затрудняет определение, какие данные попадут в этот кадр. Также в настоящее время нет способа потреблять эти данные через API Node.js.

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

Существует несколько параметров, которые можно установить для 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
  • Флаг булевого типа, активирующий режим «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
  • Флаг булевого типа, активирующий режим «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 <строка> | <Буфер> | <TypedArray> | <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, если она также работает в 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.