Zlib

Исходный код: lib/zlib.js

Модуль zlib предоставляет функции сжатия, реализованные с помощью Gzip, Deflate/Inflate и Brotli.

Для доступа к нему:

const zlib = require('zlib');

Сжатие и распаковку реализовано на основе API потоков Node.js.

Сжатие или распаковка потока (например, файла) может быть выполнено путём перенаправления исходного потока через zlib Transform поток в целевой поток:

const { createGzip } = require('zlib');
const { pipeline } = require('stream');
const {
  createReadStream,
  createWriteStream
} = require('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('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;
  });

Также возможно сжать или распаковать данные в одном шаге:

const { deflate, unzip } = require('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('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;
  });

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

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

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

const zlib = require('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 создаются одновременно. Из-за того, как некоторые операционные системы обрабатывают выделение и освобождение памяти, это может привести к значительной фрагментации памяти.

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

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

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

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

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

// Client request example
const zlib = require('zlib');
const http = require('http');
const fs = require('fs');
const { pipeline } = require('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('zlib');
const http = require('http');
const fs = require('fs');
const { pipeline } = require('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 будут генерировать ошибку при распаковке усечённых данных. Однако, если известно, что данные неполные, или требуется просмотреть только начало сжатого файла, можно подавить обработку ошибок по умолчанию, изменив метод сброса, используемый для распаковки последнего фрагмента входных данных:

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

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

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

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

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

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

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

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

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

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

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

Требования к памяти для 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('zlib');
const http = require('http');
const { pipeline } = require('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);

Константы

Константы zlib

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

Ранее константы были доступны непосредственно из require('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 <integer> По умолчанию: zlib.constants.Z_NO_FLUSH
• finishFlush <integer> По умолчанию: zlib.constants.Z_FINISH
• chunkSize <integer> По умолчанию: 16 * 1024
• windowBits <integer>
• level <integer> (только сжатие)
• memLevel <integer> (только сжатие)
• strategy <integer> (только сжатие)
• dictionary <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> (только deflate/inflate, пустой словарь по умолчанию)
• info <boolean> (Если true, возвращает объект с buffer и engine.)
• maxOutputLength <integer> Ограничивает размер выходных данных при использовании удобных методов. По умолчанию: buffer.kMaxLength

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

Класс: BrotliOptions

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

• flush <integer> По умолчанию: zlib.constants.BROTLI_OPERATION_PROCESS
• finishFlush <integer> По умолчанию: zlib.constants.BROTLI_OPERATION_FINISH
• chunkSize <integer> По умолчанию: 16 * 1024
• params <Object> Объект "ключ-значение", содержащий индексированные параметры Brotli.
• maxOutputLength <integer> Ограничивает размер выходных данных при использовании удобных методов. По умолчанию: 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
  }
});

Класс: 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

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

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

zlib.bytesRead

• <число>

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

zlib.bytesWritten

• <число>

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

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 options>

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

Создание декомпрессора Brotli

• options <brotli options>

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

Создание компрессора Deflate

• options <zlib options>

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

Создание компрессора Deflate Raw

• options <zlib options>

Создаёт и возвращает новый объект 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-битное окно.

Создание декомпрессора GZIP

• options <zlib options>

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

Создание компрессора GZIP

• options <zlib options>

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

Создание декомпрессора Inflate

• options <zlib options>

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

Создание декомпрессора Inflate Raw

• options <zlib options>

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

Создание декомпрессора UNZIP

• options <zlib options>

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

Методы для удобства

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

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

Сжатие Brotli

• buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
• options <brotli options>
• callback <Function>

Синхронное сжатие Brotli

• buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
• options <brotli options>

Сжать фрагмент данных с помощью BrotliCompress.

Декомпрессия Brotli

• buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
• options <brotli options>
• callback <Function>

Синхронная декомпрессия Brotli

• buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
• options <brotli options>

Декомпрессировать фрагмент данных с помощью BrotliDecompress.

Сжатие Deflate

• buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
• options <zlib options>
• callback <Function>

Синхронное сжатие Deflate

• buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
• options <zlib options>

Сжать фрагмент данных с помощью Deflate.

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

• buffer <Буфер> | <Массив типизированных значений> | <DataView> | <ArrayBuffer> | <строка>
• options <Опции zlib>
• callback <Функция>

zlib.deflateRawSync(buffer[, options])

• buffer <Buffer> | <Массив типизированных значений> | <DataView> | <ArrayBuffer> | <строка>
• options <Опции zlib>

Сжать блок данных с помощью DeflateRaw.

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

• buffer <Буфер> | <Массив типизированных значений> | <DataView> | <ArrayBuffer> | <строка>
• options <Опции zlib>
• callback <Функция>

zlib.gunzipSync(buffer[, options])

• buffer <Буфер> | <Массив типизированных значений> | <DataView> | <ArrayBuffer> | <строка>
• options <Опции zlib>

Разархивировать блок данных с помощью Gunzip.

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

• buffer <Буфер> | <Массив типизированных значений> | <DataView> | <ArrayBuffer> | <строка>
• options <Опции zlib>
• callback <Функция>

zlib.gzipSync(buffer[, options])

• buffer <Буфер> | <Массив типизированных значений> | <DataView> | <ArrayBuffer> | <строка>
• options <Опции zlib>

Сжать блок данных с помощью Gzip.

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

• buffer <Буфер> | <Массив типизированных значений> | <DataView> | <ArrayBuffer> | <строка>
• options <Опции zlib>
• callback <Функция>

zlib.inflateSync(buffer[, options])

• buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <строка>
• options <zlib параметры>

Распакуйте часть данных с помощью Inflate.

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

• buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <строка>
• options <zlib параметры>
• callback <Функция>

zlib.inflateRawSync(buffer[, options])

• buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <строка>
• options <zlib параметры>

Распакуйте часть данных с помощью InflateRaw.

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

• buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <строка>
• options <zlib параметры>
• callback <Функция>

zlib.unzipSync(buffer[, options])

• buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <строка>
• options <zlib параметры>

Распакуйте часть данных с помощью Unzip.