Zlib

[Estável: 2 - Estável]

Código-Fonte: lib/zlib.js

O módulo node:zlib fornece funcionalidade de compressão implementada usando Gzip, Deflate/Inflate e Brotli.

Para acessá-lo:

ESMCJS

import os from 'node:zlib'

const zlib = require('node:zlib')

Compressão e descompressão são construídas em torno da API de Streams do Node.js.

Compactar ou descompactar um stream (como um arquivo) pode ser realizado canalizando o stream de origem através de um stream zlib Transform para um stream de destino:

ESMCJS

import { createReadStream, createWriteStream } from 'node:fs'
import process from 'node:process'
import { createGzip } from 'node:zlib'
import { pipeline } from 'node:stream'

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
  }
})

const { createReadStream, createWriteStream } = require('node:fs')
const process = require('node:process')
const { createGzip } = require('node:zlib')
const { pipeline } = require('node:stream')

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
  }
})

Ou, usando a API pipeline de promise:

ESMCJS

import { createReadStream, createWriteStream } from 'node:fs'
import process from 'node:process'
import { createGzip } from 'node:zlib'
import { pipeline } from 'node:stream/promises'

async function do_gzip(input, output) {
  const gzip = createGzip()
  const source = createReadStream(input)
  const destination = createWriteStream(output)
  await pipeline(source, gzip, destination)
}

await do_gzip('input.txt', 'input.txt.gz')

const { createReadStream, createWriteStream } = require('node:fs')
const process = require('node:process')
const { createGzip } = require('node:zlib')
const { pipeline } = require('node:stream/promises')

async function do_gzip(input, output) {
  const gzip = createGzip()
  const source = createReadStream(input)
  const destination = createWriteStream(output)
  await pipeline(source, gzip, destination)
}

do_gzip('input.txt', 'input.txt.gz').catch(err => {
  console.error('An error occurred:', err)
  process.exitCode = 1
})

Também é possível compactar ou descompactar dados em uma única etapa:

ESMCJS

import process from 'node:process'
import { Buffer } from 'node:buffer'
import { deflate, unzip } from '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

import { promisify } from 'node:util'
const do_unzip = promisify(unzip)

const unzippedBuffer = await do_unzip(buffer)
console.log(unzippedBuffer.toString())

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
  })

Uso do pool de threads e considerações de desempenho

Todas as APIs zlib, exceto aquelas que são explicitamente síncronas, usam o pool de threads interno do Node.js. Isso pode levar a efeitos surpreendentes e limitações de desempenho em alguns aplicativos.

Criar e usar um grande número de objetos zlib simultaneamente pode causar fragmentação significativa da memória.

ESMCJS

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

const payload = Buffer.from('This is some data')

// AVISO: NÃO FAÇA ISSO!
for (let i = 0; i < 30000; ++i) {
  zlib.deflate(payload, (err, buffer) => {})
}

const zlib = require('node:zlib')

const payload = Buffer.from('This is some data')

// AVISO: NÃO FAÇA ISSO!
for (let i = 0; i < 30000; ++i) {
  zlib.deflate(payload, (err, buffer) => {})
}

No exemplo anterior, 30.000 instâncias de deflate são criadas simultaneamente. Devido à forma como alguns sistemas operacionais manipulam a alocação e desalocação de memória, isso pode levar a uma fragmentação significativa da memória.

É fortemente recomendado que os resultados das operações de compressão sejam armazenados em cache para evitar a duplicação de esforços.

Compactando solicitações e respostas HTTP

O módulo node:zlib pode ser usado para implementar suporte aos mecanismos de codificação de conteúdo gzip, deflate e br definidos por HTTP.

O cabeçalho HTTP Accept-Encoding é usado em uma solicitação HTTP para identificar as codificações de compressão aceitas pelo cliente. O cabeçalho Content-Encoding é usado para identificar as codificações de compressão realmente aplicadas a uma mensagem.

Os exemplos abaixo são drasticamente simplificados para mostrar o conceito básico. Usar codificação zlib pode ser caro, e os resultados devem ser armazenados em cache. Veja Ajuste do uso de memória para mais informações sobre as compensações de velocidade/memória/compressão envolvidas no uso de zlib.

ESMCJS

// Exemplo de solicitação do cliente
import fs from 'node:fs'
import zlib from 'node:zlib'
import http from 'node:http'
import process from 'node:process'
import { pipeline } from '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('Ocorreu um erro:', err)
      process.exitCode = 1
    }
  }

  switch (response.headers['content-encoding']) {
    case 'br':
      pipeline(response, zlib.createBrotliDecompress(), output, onError)
      break
    // Ou, apenas use zlib.createUnzip() para lidar com ambos os casos a seguir:
    case 'gzip':
      pipeline(response, zlib.createGunzip(), output, onError)
      break
    case 'deflate':
      pipeline(response, zlib.createInflate(), output, onError)
      break
    default:
      pipeline(response, output, onError)
      break
  }
})

// Exemplo de solicitação do cliente
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('Ocorreu um erro:', err)
      process.exitCode = 1
    }
  }

  switch (response.headers['content-encoding']) {
    case 'br':
      pipeline(response, zlib.createBrotliDecompress(), output, onError)
      break
    // Ou, apenas use zlib.createUnzip() para lidar com ambos os casos a seguir:
    case 'gzip':
      pipeline(response, zlib.createGunzip(), output, onError)
      break
    case 'deflate':
      pipeline(response, zlib.createInflate(), output, onError)
      break
    default:
      pipeline(response, output, onError)
      break
  }
})

ESMCJS

// Exemplo de servidor
// Executar uma operação gzip a cada solicitação é bastante caro.
// Seria muito mais eficiente armazenar em cache o buffer comprimido.
import zlib from 'node:zlib'
import http from 'node:http'
import fs from 'node:fs'
import { pipeline } from 'node:stream'

http
  .createServer((request, response) => {
    const raw = fs.createReadStream('index.html')
    // Armazene uma versão comprimida e uma não comprimida do recurso.
    response.setHeader('Vary', 'Accept-Encoding')
    const acceptEncoding = request.headers['accept-encoding'] || ''

    const onError = err => {
      if (err) {
        // Se ocorrer um erro, não há muito o que podemos fazer porque
        // o servidor já enviou o código de resposta 200 e
        // uma certa quantidade de dados já foi enviada para o cliente.
        // O melhor que podemos fazer é encerrar a resposta imediatamente
        // e registrar o erro.
        response.end()
        console.error('Ocorreu um erro:', err)
      }
    }

    // Nota: Este não é um analisador de accept-encoding conformante.
    // Veja 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)

// Exemplo de servidor
// Executar uma operação gzip a cada solicitação é bastante caro.
// Seria muito mais eficiente armazenar em cache o buffer comprimido.
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')
    // Armazene uma versão comprimida e uma não comprimida do recurso.
    response.setHeader('Vary', 'Accept-Encoding')
    const acceptEncoding = request.headers['accept-encoding'] || ''

    const onError = err => {
      if (err) {
        // Se ocorrer um erro, não há muito o que podemos fazer porque
        // o servidor já enviou o código de resposta 200 e
        // uma certa quantidade de dados já foi enviada para o cliente.
        // O melhor que podemos fazer é encerrar a resposta imediatamente
        // e registrar o erro.
        response.end()
        console.error('Ocorreu um erro:', err)
      }
    }

    // Nota: Este não é um analisador de accept-encoding conformante.
    // Veja 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)

Por padrão, os métodos zlib lançarão um erro ao descompactar dados truncados. No entanto, se for sabido que os dados estão incompletos, ou o desejo é inspecionar apenas o início de um arquivo comprimido, é possível suprimir o tratamento de erro padrão alterando o método de limpeza usado para descompactar o último bloco de dados de entrada:

// Esta é uma versão truncada do buffer dos exemplos acima
const buffer = Buffer.from('eJzT0yMA', 'base64')

zlib.unzip(
  buffer,
  // Para Brotli, o equivalente é zlib.constants.BROTLI_OPERATION_FLUSH.
  { finishFlush: zlib.constants.Z_SYNC_FLUSH },
  (err, buffer) => {
    if (err) {
      console.error('Ocorreu um erro:', err)
      process.exitCode = 1
    }
    console.log(buffer.toString())
  }
)

Isso não alterará o comportamento em outras situações de lançamento de erro, por exemplo, quando os dados de entrada tiverem um formato inválido. Usando este método, não será possível determinar se a entrada terminou prematuramente ou se faltam as verificações de integridade, tornando necessário verificar manualmente se o resultado descompactado é válido.

Ajuste do uso de memória

Para fluxos baseados em zlib

De zlib/zconf.h, modificado para uso no Node.js:

Os requisitos de memória para deflate são (em bytes):

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

Ou seja: 128K para windowBits = 15 + 128K para memLevel = 8 (valores padrão) mais alguns kilobytes para objetos pequenos.

Por exemplo, para reduzir os requisitos de memória padrão de 256K para 128K, as opções devem ser definidas como:

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

Isso, no entanto, geralmente degradará a compressão.

Os requisitos de memória para inflate são (em bytes) 1 \<\< windowBits. Ou seja, 32K para windowBits = 15 (valor padrão) mais alguns kilobytes para objetos pequenos.

Isso é além de um único buffer interno de slab de saída do tamanho chunkSize, que é 16K por padrão.

A velocidade de compressão zlib é afetada mais dramaticamente pela configuração level. Um nível superior resultará em melhor compressão, mas levará mais tempo para ser concluído. Um nível inferior resultará em menos compressão, mas será muito mais rápido.

Em geral, opções de maior uso de memória significarão que o Node.js terá que fazer menos chamadas para zlib porque será capaz de processar mais dados em cada operação write. Portanto, este é outro fator que afeta a velocidade, ao custo do uso de memória.

Para fluxos baseados em Brotli

Existem equivalentes às opções zlib para fluxos baseados em Brotli, embora essas opções tenham faixas diferentes das opções zlib:

A opção level do zlib corresponde à opção BROTLI_PARAM_QUALITY do Brotli.
A opção windowBits do zlib corresponde à opção BROTLI_PARAM_LGWIN do Brotli.

Veja abaixo para mais detalhes sobre as opções específicas do Brotli.

Fluxo

Chamar .flush() em um fluxo de compressão fará com que zlib retorne o máximo de saída possível no momento. Isso pode ter o custo de uma qualidade de compressão degradada, mas pode ser útil quando os dados precisam estar disponíveis o mais rápido possível.

No exemplo a seguir, flush() é usado para escrever uma resposta HTTP parcial comprimida para o cliente:

ESMCJS

import zlib from 'node:zlib'
import http from 'node:http'
import { pipeline } from 'node:stream'

http
  .createServer((request, response) => {
    // Para simplificar, as verificações Accept-Encoding são omitidas.
    response.writeHead(200, { 'content-encoding': 'gzip' })
    const output = zlib.createGzip()
    let i

    pipeline(output, response, err => {
      if (err) {
        // Se ocorrer um erro, não há muito o que podemos fazer porque
        // o servidor já enviou o código de resposta 200 e
        // uma certa quantidade de dados já foi enviada para o cliente.
        // O melhor que podemos fazer é encerrar a resposta imediatamente
        // e registrar o erro.
        clearInterval(i)
        response.end()
        console.error('Ocorreu um erro:', err)
      }
    })

    i = setInterval(() => {
      output.write(`O horário atual é ${Date()}\n`, () => {
        // Os dados foram passados para o zlib, mas o algoritmo de compressão pode
        // ter decidido armazenar os dados em buffer para uma compressão mais eficiente.
        // Chamar .flush() tornará os dados disponíveis assim que o cliente
        // estiver pronto para recebê-los.
        output.flush()
      })
    }, 1000)
  })
  .listen(1337)

const zlib = require('node:zlib')
const http = require('node:http')
const { pipeline } = require('node:stream')

http
  .createServer((request, response) => {
    // Para simplificar, as verificações Accept-Encoding são omitidas.
    response.writeHead(200, { 'content-encoding': 'gzip' })
    const output = zlib.createGzip()
    let i

    pipeline(output, response, err => {
      if (err) {
        // Se ocorrer um erro, não há muito o que podemos fazer porque
        // o servidor já enviou o código de resposta 200 e
        // uma certa quantidade de dados já foi enviada para o cliente.
        // O melhor que podemos fazer é encerrar a resposta imediatamente
        // e registrar o erro.
        clearInterval(i)
        response.end()
        console.error('Ocorreu um erro:', err)
      }
    })

    i = setInterval(() => {
      output.write(`O horário atual é ${Date()}\n`, () => {
        // Os dados foram passados para o zlib, mas o algoritmo de compressão pode
        // ter decidido armazenar os dados em buffer para uma compressão mais eficiente.
        // Chamar .flush() tornará os dados disponíveis assim que o cliente
        // estiver pronto para recebê-los.
        output.flush()
      })
    }, 1000)
  })
  .listen(1337)

Constantes

Adicionado em: v0.5.8

Constantes zlib

Todas as constantes definidas em zlib.h também são definidas em require('node:zlib').constants. No curso normal das operações, não será necessário usar essas constantes. Elas são documentadas para que sua presença não seja surpreendente. Esta seção é extraída quase diretamente da documentação zlib.

Anteriormente, as constantes estavam disponíveis diretamente de require('node:zlib'), por exemplo, zlib.Z_NO_FLUSH. O acesso às constantes diretamente do módulo ainda é possível atualmente, mas está obsoleto.

Valores de flush permitidos.

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

Códigos de retorno para as funções de compressão/descompressão. Valores negativos são erros, valores positivos são usados para eventos especiais, mas normais.

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

Níveis de compressão.

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

Estratégia de compressão.

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

Constantes Brotli

Adicionado em: v11.7.0, v10.16.0

Existem várias opções e outras constantes disponíveis para fluxos baseados em Brotli:

Operações de Flush

Os seguintes valores são operações de flush válidas para fluxos baseados em Brotli:

zlib.constants.BROTLI_OPERATION_PROCESS (padrão para todas as operações)
zlib.constants.BROTLI_OPERATION_FLUSH (padrão ao chamar .flush())
zlib.constants.BROTLI_OPERATION_FINISH (padrão para o último bloco)
zlib.constants.BROTLI_OPERATION_EMIT_METADATA
- Esta operação particular pode ser difícil de usar em um contexto Node.js, pois a camada de streaming dificulta saber quais dados acabarão neste quadro. Além disso, atualmente não há como consumir esses dados por meio da API Node.js.

Opções do compressor

Existem várias opções que podem ser definidas nos codificadores Brotli, afetando a eficiência e a velocidade de compressão. Tanto as chaves quanto os valores podem ser acessados como propriedades do objeto zlib.constants.

As opções mais importantes são:

BROTLI_PARAM_MODE
- BROTLI_MODE_GENERIC (padrão)
- BROTLI_MODE_TEXT, ajustado para texto UTF-8
- BROTLI_MODE_FONT, ajustado para fontes WOFF 2.0
BROTLI_PARAM_QUALITY
- Varia de BROTLI_MIN_QUALITY a BROTLI_MAX_QUALITY, com um padrão de BROTLI_DEFAULT_QUALITY.
BROTLI_PARAM_SIZE_HINT
- Valor inteiro representando o tamanho de entrada esperado; o padrão é 0 para um tamanho de entrada desconhecido.

Os seguintes sinalizadores podem ser definidos para controle avançado sobre o algoritmo de compressão e ajuste do uso da memória:

BROTLI_PARAM_LGWIN
- Varia de BROTLI_MIN_WINDOW_BITS a BROTLI_MAX_WINDOW_BITS, com um padrão de BROTLI_DEFAULT_WINDOW, ou até BROTLI_LARGE_MAX_WINDOW_BITS se o sinalizador BROTLI_PARAM_LARGE_WINDOW estiver definido.
BROTLI_PARAM_LGBLOCK
- Varia de BROTLI_MIN_INPUT_BLOCK_BITS a BROTLI_MAX_INPUT_BLOCK_BITS.
BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING
- Sinalizador booleano que diminui a taxa de compressão em favor da velocidade de descompressão.
BROTLI_PARAM_LARGE_WINDOW
- Sinalizador booleano que habilita o modo “Large Window Brotli” (incompatível com o formato Brotli como padronizado em RFC 7932).
BROTLI_PARAM_NPOSTFIX
- Varia de 0 a BROTLI_MAX_NPOSTFIX.
BROTLI_PARAM_NDIRECT
- Varia de 0 a 15 \<\< NPOSTFIX em passos de 1 \<\< NPOSTFIX.

Opções do descompactador

Estas opções avançadas estão disponíveis para controlar a descompressão:

BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION
- Sinalizador booleano que afeta os padrões de alocação de memória interna.
BROTLI_DECODER_PARAM_LARGE_WINDOW
- Sinalizador booleano que habilita o modo “Large Window Brotli” (incompatível com o formato Brotli como padronizado em RFC 7932).

Classe: `Options`

[Histórico]

Versão	Alterações
v14.5.0, v12.19.0	A opção `maxOutputLength` agora é suportada.
v9.4.0	A opção `dictionary` pode ser um `ArrayBuffer`.
v8.0.0	A opção `dictionary` agora pode ser um `Uint8Array`.
v5.11.0	A opção `finishFlush` agora é suportada.
v0.11.1	Adicionada em: v0.11.1

Cada classe baseada em zlib recebe um objeto options. Nenhuma opção é necessária.

Algumas opções são relevantes apenas ao comprimir e são ignoradas pelas classes de descompressão.

flush <inteiro> Padrão: zlib.constants.Z_NO_FLUSH
finishFlush <inteiro> Padrão: zlib.constants.Z_FINISH
chunkSize <inteiro> Padrão: 16 * 1024
windowBits <inteiro>
level <inteiro> (apenas compressão)
memLevel <inteiro> (apenas compressão)
strategy <inteiro> (apenas compressão)
dictionary <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> (apenas deflate/inflate, dicionário vazio por padrão)
info <booleano> (Se true, retorna um objeto com buffer e engine.)
maxOutputLength <inteiro> Limita o tamanho da saída ao usar métodos de conveniência. Padrão: buffer.kMaxLength

Veja a documentação deflateInit2 e inflateInit2 para mais informações.

Class: `BrotliOptions`

[Histórico]

Versão	Alterações
v14.5.0, v12.19.0	A opção `maxOutputLength` agora é suportada.
v11.7.0	Adicionada em: v11.7.0

Cada classe baseada em Brotli recebe um objeto options. Todas as opções são opcionais.

flush <inteiro> Padrão: zlib.constants.BROTLI_OPERATION_PROCESS
finishFlush <inteiro> Padrão: zlib.constants.BROTLI_OPERATION_FINISH
chunkSize <inteiro> Padrão: 16 * 1024
params <Objeto> Objeto chave-valor contendo parâmetros Brotli indexados.
maxOutputLength <inteiro> Limita o tamanho da saída ao usar métodos de conveniência. Padrão: buffer.kMaxLength

Por exemplo:

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

Class: `zlib.BrotliCompress`

Adicionada em: v11.7.0, v10.16.0

Comprime dados usando o algoritmo Brotli.

Class: `zlib.BrotliDecompress`

Adicionada em: v11.7.0, v10.16.0

Descomprime dados usando o algoritmo Brotli.

Class: `zlib.Deflate`

Adicionada em: v0.5.8

Comprime dados usando deflate.

Class: `zlib.DeflateRaw`

Adicionada em: v0.5.8

Comprime dados usando deflate e não anexa um cabeçalho zlib.

Class: `zlib.Gunzip`

[Histórico]

Versão	Alterações
v6.0.0	Lixo final no final do fluxo de entrada agora resultará em um evento `'error'`.
v5.9.0	Múltiplos membros de arquivo gzip concatenados são suportados agora.
v5.0.0	Um fluxo de entrada truncado agora resultará em um evento `'error'`.
v0.5.8	Adicionada em: v0.5.8

Descomprime um fluxo gzip.

Classe: `zlib.Gzip`

Adicionado em: v0.5.8

Comprime dados usando gzip.

Classe: `zlib.Inflate`

[Histórico]

Versão	Alterações
v5.0.0	Um fluxo de entrada truncado agora resultará em um evento `'error'`.
v0.5.8	Adicionada em: v0.5.8

Descomprime um fluxo deflate.

Classe: `zlib.InflateRaw`

[Histórico]

Versão	Alterações
v6.8.0	Dicionários personalizados agora são suportados por `InflateRaw`.
v5.0.0	Um fluxo de entrada truncado agora resultará em um evento `'error'`.
v0.5.8	Adicionada em: v0.5.8

Descomprime um fluxo deflate bruto.

Classe: `zlib.Unzip`

Adicionado em: v0.5.8

Descomprime um fluxo comprimido Gzip ou Deflate detectando automaticamente o cabeçalho.

Classe: `zlib.ZlibBase`

[Histórico]

Versão	Alterações
v11.7.0, v10.16.0	Esta classe foi renomeada de `Zlib` para `ZlibBase`.
v0.5.8	Adicionada em: v0.5.8

Não exportado pelo módulo node:zlib. É documentado aqui porque é a classe base das classes de compressor/descompressor.

Esta classe herda de stream.Transform, permitindo que objetos node:zlib sejam usados em pipes e operações de stream semelhantes.

`zlib.bytesWritten`

Adicionado em: v10.0.0

<número>

A propriedade zlib.bytesWritten especifica o número de bytes escritos para o mecanismo, antes dos bytes serem processados (comprimidos ou descomprimidos, conforme apropriado para a classe derivada).

`zlib.crc32(data[, value])`

Adicionado em: v22.2.0, v20.15.0

data <string> | <Buffer> | <TypedArray> | <DataView> Quando data é uma string, ela será codificada como UTF-8 antes de ser usada para o cálculo.
value <inteiro> Um valor inicial opcional. Deve ser um inteiro sem sinal de 32 bits. Padrão: 0
Retorna: <inteiro> Um inteiro sem sinal de 32 bits contendo o checksum.

Calcula um checksum de Verificação de Redundância Cíclica de 32 bits de data. Se value for especificado, ele será usado como o valor inicial do checksum, caso contrário, 0 será usado como o valor inicial.

O algoritmo CRC é projetado para calcular checksums e detectar erros na transmissão de dados. Não é adequado para autenticação criptográfica.

Para ser consistente com outras APIs, se o data for uma string, ele será codificado com UTF-8 antes de ser usado para o cálculo. Se os usuários usam apenas o Node.js para calcular e comparar os checksums, isso funciona bem com outras APIs que usam a codificação UTF-8 por padrão.

Algumas bibliotecas JavaScript de terceiros calculam o checksum em uma string com base em str.charCodeAt() para que possa ser executado em navegadores. Se os usuários quiserem comparar o checksum calculado com esse tipo de biblioteca no navegador, é melhor usar a mesma biblioteca no Node.js se ela também for executada no Node.js. Se os usuários tiverem que usar zlib.crc32() para comparar o checksum produzido por essa biblioteca de terceiros:

ESMCJS

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

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])`

Adicionado em: v0.9.4

callback <Function>

Fecha o manipulador subjacente.

`zlib.flush([kind, ]callback)`

Adicionado em: v0.5.8

kind Padrão: zlib.constants.Z_FULL_FLUSH para fluxos baseados em zlib, zlib.constants.BROTLI_OPERATION_FLUSH para fluxos baseados em Brotli.
callback <Function>

Limpa os dados pendentes. Não chame isso levianamente, limpezas prematuras impactam negativamente a eficácia do algoritmo de compressão.

Chamar isso apenas limpa os dados do estado interno zlib, e não executa nenhum tipo de limpeza no nível dos fluxos. Em vez disso, comporta-se como uma chamada normal para .write(), ou seja, será colocado na fila atrás de outras gravações pendentes e só produzirá saída quando os dados estiverem sendo lidos do fluxo.

`zlib.params(level, strategy, callback)`

Adicionado em: v0.11.4

level <inteiro>
strategy <inteiro>
callback <Function>

Esta função só está disponível para fluxos baseados em zlib, ou seja, não Brotli.

Atualiza dinamicamente o nível de compressão e a estratégia de compressão. Apenas aplicável ao algoritmo deflate.

`zlib.reset()`

Adicionado em: v0.7.0

Redefine o compressor/descompressor para os padrões de fábrica. Apenas aplicável aos algoritmos inflate e deflate.

`zlib.constants`

Adicionado em: v7.0.0

Fornece um objeto que enumera as constantes relacionadas ao Zlib.

`zlib.createBrotliCompress([options])`

Adicionado em: v11.7.0, v10.16.0

options <opções brotli>

Cria e retorna um novo objeto BrotliCompress.

`zlib.createBrotliDecompress([options])`

Adicionado em: v11.7.0, v10.16.0

options <opções brotli>

Cria e retorna um novo objeto BrotliDecompress.

`zlib.createDeflate([options])`

Adicionado em: v0.5.8

options <opções zlib>

Cria e retorna um novo objeto Deflate.

`zlib.createDeflateRaw([options])`

Adicionado em: v0.5.8

options <opções zlib>

Cria e retorna um novo objeto DeflateRaw.

Uma atualização do zlib de 1.2.8 para 1.2.11 alterou o comportamento quando windowBits é definido como 8 para fluxos de deflate raw. O zlib definiria automaticamente windowBits como 9 se fosse inicialmente definido como 8. Versões mais novas do zlib lançarão uma exceção, portanto, o Node.js restaurou o comportamento original de atualizar um valor de 8 para 9, uma vez que passar windowBits = 9 para o zlib resulta em um fluxo comprimido que efetivamente usa apenas uma janela de 8 bits.

`zlib.createGunzip([options])`

Adicionado em: v0.5.8

options <opções zlib>

Cria e retorna um novo objeto Gunzip.

`zlib.createGzip([options])`

Adicionado em: v0.5.8

options <opções zlib>

Cria e retorna um novo objeto Gzip. Veja o exemplo.

`zlib.createInflate([options])`

Adicionado em: v0.5.8

options <opções zlib>

Cria e retorna um novo objeto Inflate.

`zlib.createInflateRaw([options])`

Adicionado em: v0.5.8

options <opções zlib>

Cria e retorna um novo objeto InflateRaw.

`zlib.createUnzip([options])`

Adicionado em: v0.5.8

options <opções zlib>

Cria e retorna um novo objeto Unzip.

Métodos de conveniência

Todos estes recebem um Buffer, TypedArray, DataView, ArrayBuffer ou string como primeiro argumento, um segundo argumento opcional para fornecer opções às classes zlib e chamará o callback fornecido com callback(error, result).

Cada método tem uma contraparte *Sync, que aceita os mesmos argumentos, mas sem um callback.

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

Adicionado em: v11.7.0, v10.16.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções brotli>
callback <Function>

`zlib.brotliCompressSync(buffer[, options])`

Adicionado em: v11.7.0, v10.16.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções brotli>

Comprime um bloco de dados com BrotliCompress.

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

Adicionado em: v11.7.0, v10.16.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções brotli>
callback <Function>

`zlib.brotliDecompressSync(buffer[, options])`

Adicionado em: v11.7.0, v10.16.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções brotli>

Descomprima um bloco de dados com BrotliDecompress.

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

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.6.0	Adicionada em: v0.6.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>
callback <Function>

`zlib.deflateSync(buffer[, options])`

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.11.12	Adicionado em: v0.11.12

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>

Comprime um bloco de dados com Deflate.

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

[Histórico]

Versão	Alterações
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.6.0	Adicionado em: v0.6.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>
callback <Function>

`zlib.deflateRawSync(buffer[, options])`

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.11.12	Adicionado em: v0.11.12

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>

Comprime um bloco de dados com DeflateRaw.

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

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.6.0	Adicionado em: v0.6.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>
callback <Função>

`zlib.gunzipSync(buffer[, options])`

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.11.12	Adicionado em: v0.11.12

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>

Descomprima um bloco de dados com Gunzip.

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

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.6.0	Adicionado em: v0.6.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>
callback <Função>

`zlib.gzipSync(buffer[, options])`

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.11.12	Adicionado em: v0.11.12

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>

Comprime um bloco de dados com Gzip.

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

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.6.0	Adicionado em: v0.6.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>
callback <Function>

`zlib.inflateSync(buffer[, options])`

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.11.12	Adicionado em: v0.11.12

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>

Descomprime um bloco de dados com Inflate.

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

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.6.0	Adicionado em: v0.6.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>
callback <Function>

`zlib.inflateRawSync(buffer[, options])`

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.11.12	Adicionado em: v0.11.12

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>

Descomprima um bloco de dados com InflateRaw.

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

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.6.0	Adicionado em: v0.6.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>
callback <Function>

`zlib.unzipSync(buffer[, options])`

[Histórico]

Versão	Alterações
v9.4.0	O parâmetro `buffer` pode ser um `ArrayBuffer`.
v8.0.0	O parâmetro `buffer` pode ser qualquer `TypedArray` ou `DataView`.
v8.0.0	O parâmetro `buffer` agora pode ser um `Uint8Array`.
v0.11.12	Adicionado em: v0.11.12

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opções zlib>

Descomprima um bloco de dados com Unzip.

Zlib ​

Uso do pool de threads e considerações de desempenho ​

Compactando solicitações e respostas HTTP ​

Ajuste do uso de memória ​

Para fluxos baseados em zlib ​

Para fluxos baseados em Brotli ​

Fluxo ​

Constantes ​

Constantes zlib ​

Constantes Brotli ​

Operações de Flush ​

Opções do compressor ​

Opções do descompactador ​

Classe: Options ​

Class: BrotliOptions ​

Class: zlib.BrotliCompress ​

Class: zlib.BrotliDecompress ​

Class: zlib.Deflate ​

Class: zlib.DeflateRaw ​

Class: zlib.Gunzip ​

Classe: zlib.Gzip ​

Classe: zlib.Inflate ​

Classe: zlib.InflateRaw ​

Classe: zlib.Unzip ​

Classe: zlib.ZlibBase ​

zlib.bytesWritten ​

zlib.crc32(data[, value]) ​

zlib.close([callback]) ​

zlib.flush([kind, ]callback) ​

zlib.params(level, strategy, callback) ​

zlib.reset() ​

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]) ​

Métodos de conveniência ​

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

Uso do pool de threads e considerações de desempenho

Compactando solicitações e respostas HTTP

Ajuste do uso de memória

Para fluxos baseados em zlib

Para fluxos baseados em Brotli

Fluxo

Constantes

Constantes zlib

Constantes Brotli

Operações de Flush

Opções do compressor

Opções do descompactador

Classe: `Options`

Class: `BrotliOptions`

Class: `zlib.BrotliCompress`

Class: `zlib.BrotliDecompress`

Class: `zlib.Deflate`

Class: `zlib.DeflateRaw`

Class: `zlib.Gunzip`

Classe: `zlib.Gzip`

Classe: `zlib.Inflate`

Classe: `zlib.InflateRaw`

Classe: `zlib.Unzip`

Classe: `zlib.ZlibBase`

`zlib.bytesWritten`

`zlib.crc32(data[, value])`

`zlib.close([callback])`

`zlib.flush([kind, ]callback)`

`zlib.params(level, strategy, callback)`

`zlib.reset()`

`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])`

Métodos de conveniência

`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])`