Zlib

[Estable: 2 - Estable]

Código fuente: lib/zlib.js

El módulo node:zlib proporciona funcionalidad de compresión implementada utilizando Gzip, Deflate/Inflate y Brotli.

Para acceder a él:

ESMCJS

import os from 'node:zlib'

const zlib = require('node:zlib')

La compresión y descompresión se construyen alrededor de la API de Streams de Node.js.

La compresión o descompresión de un flujo (como un archivo) se puede lograr canalizando el flujo de origen a través de un flujo Transform de zlib a un flujo 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('Ha ocurrido un error:', 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('Ha ocurrido un error:', err)
    process.exitCode = 1
  }
})

O, usando la API pipeline de promesa:

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('Ha ocurrido un error:', err)
  process.exitCode = 1
})

También es posible comprimir o descomprimir datos en un solo paso:

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('Ha ocurrido un error:', err)
    process.exitCode = 1
  }
  console.log(buffer.toString('base64'))
})

const buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64')
unzip(buffer, (err, buffer) => {
  if (err) {
    console.error('Ha ocurrido un error:', err)
    process.exitCode = 1
  }
  console.log(buffer.toString())
})

// O, Promisificado

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('Ha ocurrido un error:', err)
    process.exitCode = 1
  }
  console.log(buffer.toString('base64'))
})

const buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64')
unzip(buffer, (err, buffer) => {
  if (err) {
    console.error('Ha ocurrido un error:', err)
    process.exitCode = 1
  }
  console.log(buffer.toString())
})

// O, Promisificado

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

do_unzip(buffer)
  .then(buf => console.log(buf.toString()))
  .catch(err => {
    console.error('Ha ocurrido un error:', err)
    process.exitCode = 1
  })

Uso del Threadpool y consideraciones de rendimiento

Todas las API de zlib, excepto aquellas que son explícitamente síncronas, utilizan el threadpool interno de Node.js. Esto puede llevar a efectos sorprendentes y limitaciones de rendimiento en algunas aplicaciones.

Crear y usar un gran número de objetos zlib simultáneamente puede causar una fragmentación de memoria significativa.

ESMCJS

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

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

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

En el ejemplo anterior, se crean 30,000 instancias de deflate concurrentemente. Debido a cómo algunos sistemas operativos manejan la asignación y desasignación de memoria, esto puede llevar a una fragmentación de memoria significativa.

Se recomienda encarecidamente que los resultados de las operaciones de compresión se almacenen en caché para evitar la duplicación de esfuerzos.

Comprimiendo peticiones y respuestas HTTP

El módulo node:zlib puede utilizarse para implementar soporte para los mecanismos de codificación de contenido gzip, deflate y br definidos por HTTP.

La cabecera HTTP Accept-Encoding se utiliza dentro de una petición HTTP para identificar las codificaciones de compresión aceptadas por el cliente. La cabecera Content-Encoding se utiliza para identificar las codificaciones de compresión que se aplican realmente a un mensaje.

Los ejemplos que se dan a continuación están drásticamente simplificados para mostrar el concepto básico. El uso de la codificación zlib puede ser costoso, y los resultados deben almacenarse en caché. Consulte Ajuste del uso de memoria para obtener más información sobre las ventajas y desventajas de velocidad/memoria/compresión que implica el uso de zlib.

ESMCJS

// Ejemplo de petición de 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('Ha ocurrido un error:', err)
      process.exitCode = 1
    }
  }

  switch (response.headers['content-encoding']) {
    case 'br':
      pipeline(response, zlib.createBrotliDecompress(), output, onError)
      break
    // O, simplemente utiliza zlib.createUnzip() para manejar ambos de los siguientes casos:
    case 'gzip':
      pipeline(response, zlib.createGunzip(), output, onError)
      break
    case 'deflate':
      pipeline(response, zlib.createInflate(), output, onError)
      break
    default:
      pipeline(response, output, onError)
      break
  }
})

// Ejemplo de petición de 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('Ha ocurrido un error:', err)
      process.exitCode = 1
    }
  }

  switch (response.headers['content-encoding']) {
    case 'br':
      pipeline(response, zlib.createBrotliDecompress(), output, onError)
      break
    // O, simplemente utiliza zlib.createUnzip() para manejar ambos de los siguientes casos:
    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

// ejemplo de servidor
// Ejecutar una operación gzip en cada solicitud es bastante costoso.
// Sería mucho más eficiente almacenar en caché el búfer 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')
    // Almacena tanto una versión comprimida como una sin comprimir del recurso.
    response.setHeader('Vary', 'Accept-Encoding')
    const acceptEncoding = request.headers['accept-encoding'] || ''

    const onError = err => {
      if (err) {
        // Si se produce un error, no hay mucho que podamos hacer porque
        // el servidor ya ha enviado el código de respuesta 200 y
        // ya se ha enviado cierta cantidad de datos al cliente.
        // Lo mejor que podemos hacer es terminar la respuesta inmediatamente
        // y registrar el error.
        response.end()
        console.error('Ha ocurrido un error:', err)
      }
    }

    // Nota: Este no es un analizador de accept-encoding conforme.
    // Consulta 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)

// ejemplo de servidor
// Ejecutar una operación gzip en cada solicitud es bastante costoso.
// Sería mucho más eficiente almacenar en caché el búfer 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')
    // Almacena tanto una versión comprimida como una sin comprimir del recurso.
    response.setHeader('Vary', 'Accept-Encoding')
    const acceptEncoding = request.headers['accept-encoding'] || ''

    const onError = err => {
      if (err) {
        // Si se produce un error, no hay mucho que podamos hacer porque
        // el servidor ya ha enviado el código de respuesta 200 y
        // ya se ha enviado cierta cantidad de datos al cliente.
        // Lo mejor que podemos hacer es terminar la respuesta inmediatamente
        // y registrar el error.
        response.end()
        console.error('Ha ocurrido un error:', err)
      }
    }

    // Nota: Este no es un analizador de accept-encoding conforme.
    // Consulta 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)

De forma predeterminada, los métodos zlib lanzarán un error al descomprimir datos truncados. Sin embargo, si se sabe que los datos están incompletos o se desea inspeccionar solo el principio de un archivo comprimido, es posible suprimir el manejo de errores predeterminado cambiando el método de vaciado que se utiliza para descomprimir el último fragmento de datos de entrada:

// Esta es una versión truncada del búfer de los ejemplos anteriores
const buffer = Buffer.from('eJzT0yMA', 'base64')

zlib.unzip(
  buffer,
  // Para Brotli, el equivalente es zlib.constants.BROTLI_OPERATION_FLUSH.
  { finishFlush: zlib.constants.Z_SYNC_FLUSH },
  (err, buffer) => {
    if (err) {
      console.error('Ha ocurrido un error:', err)
      process.exitCode = 1
    }
    console.log(buffer.toString())
  }
)

Esto no cambiará el comportamiento en otras situaciones en las que se lanzan errores, por ejemplo, cuando los datos de entrada tienen un formato no válido. Utilizando este método, no será posible determinar si la entrada terminó prematuramente o carece de las comprobaciones de integridad, lo que hace necesario comprobar manualmente que el resultado descomprimido es válido.

Ajuste del uso de memoria

Para flujos basados en zlib

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

Los requisitos de memoria para deflate son (en bytes):

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

Es decir: 128K para windowBits = 15 + 128K para memLevel = 8 (valores predeterminados) más unos pocos kilobytes para objetos pequeños.

Por ejemplo, para reducir los requisitos de memoria predeterminados de 256K a 128K, las opciones deberían establecerse en:

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

Esto, sin embargo, generalmente degradará la compresión.

Los requisitos de memoria para inflate son (en bytes) 1 \<\< windowBits. Es decir, 32K para windowBits = 15 (valor predeterminado) más unos pocos kilobytes para objetos pequeños.

Esto se suma a un único búfer de salida interno de tamaño chunkSize, que de forma predeterminada es de 16K.

La velocidad de compresión de zlib se ve afectada de forma más dramática por la configuración de level. Un nivel más alto resultará en una mejor compresión, pero tardará más en completarse. Un nivel más bajo resultará en menos compresión, pero será mucho más rápido.

En general, las opciones de mayor uso de memoria significarán que Node.js tiene que hacer menos llamadas a zlib porque podrá procesar más datos en cada operación write. Entonces, este es otro factor que afecta la velocidad, a costa del uso de memoria.

Para flujos basados en Brotli

Existen equivalentes a las opciones de zlib para flujos basados en Brotli, aunque estas opciones tienen rangos diferentes a los de zlib:

La opción level de zlib coincide con la opción BROTLI_PARAM_QUALITY de Brotli.
La opción windowBits de zlib coincide con la opción BROTLI_PARAM_LGWIN de Brotli.

Consulta abajo para obtener más detalles sobre las opciones específicas de Brotli.

Vaciado

Llamar a .flush() en un flujo de compresión hará que zlib devuelva la mayor cantidad posible de salida en ese momento. Esto puede conllevar una degradación de la calidad de la compresión, pero puede ser útil cuando los datos deben estar disponibles lo antes posible.

En el siguiente ejemplo, se utiliza flush() para escribir una respuesta HTTP parcial comprimida al cliente:

ESMCJS

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

http
  .createServer((request, response) => {
    // En aras de la simplicidad, se omiten las comprobaciones de Accept-Encoding.
    response.writeHead(200, { 'content-encoding': 'gzip' })
    const output = zlib.createGzip()
    let i

    pipeline(output, response, err => {
      if (err) {
        // Si se produce un error, no hay mucho que podamos hacer porque
        // el servidor ya ha enviado el código de respuesta 200 y
        // ya se ha enviado alguna cantidad de datos al cliente.
        // Lo mejor que podemos hacer es terminar la respuesta inmediatamente
        // y registrar el error.
        clearInterval(i)
        response.end()
        console.error('Se ha producido un error:', err)
      }
    })

    i = setInterval(() => {
      output.write(`La hora actual es ${Date()}\n`, () => {
        // Los datos se han pasado a zlib, pero el algoritmo de compresión puede
        // haber decidido almacenar los datos en búfer para una compresión más eficiente.
        // Llamar a .flush() hará que los datos estén disponibles tan pronto como el cliente
        // esté listo para recibirlos.
        output.flush()
      })
    }, 1000)
  })
  .listen(1337)

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

http
  .createServer((request, response) => {
    // En aras de la simplicidad, se omiten las comprobaciones de Accept-Encoding.
    response.writeHead(200, { 'content-encoding': 'gzip' })
    const output = zlib.createGzip()
    let i

    pipeline(output, response, err => {
      if (err) {
        // Si se produce un error, no hay mucho que podamos hacer porque
        // el servidor ya ha enviado el código de respuesta 200 y
        // ya se ha enviado alguna cantidad de datos al cliente.
        // Lo mejor que podemos hacer es terminar la respuesta inmediatamente
        // y registrar el error.
        clearInterval(i)
        response.end()
        console.error('Se ha producido un error:', err)
      }
    })

    i = setInterval(() => {
      output.write(`La hora actual es ${Date()}\n`, () => {
        // Los datos se han pasado a zlib, pero el algoritmo de compresión puede
        // haber decidido almacenar los datos en búfer para una compresión más eficiente.
        // Llamar a .flush() hará que los datos estén disponibles tan pronto como el cliente
        // esté listo para recibirlos.
        output.flush()
      })
    }, 1000)
  })
  .listen(1337)

Constantes

Añadido en: v0.5.8

Constantes de zlib

Todas las constantes definidas en zlib.h también se definen en require('node:zlib').constants. En el curso normal de las operaciones, no será necesario utilizar estas constantes. Se documentan para que su presencia no sea sorprendente. Esta sección se toma casi directamente de la documentación de zlib.

Anteriormente, las constantes estaban disponibles directamente desde require('node:zlib'), por ejemplo zlib.Z_NO_FLUSH. El acceso a las constantes directamente desde el módulo todavía es posible, pero está obsoleto.

Valores de vaciado 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 las funciones de compresión/descompresión. Los valores negativos son errores, los valores positivos se utilizan para eventos especiales pero normales.

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

Niveles de compresión.

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

Estrategia de compresión.

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

Constantes de Brotli

Añadido en: v11.7.0, v10.16.0

Existen varias opciones y otras constantes disponibles para los flujos basados en Brotli:

Operaciones de vaciado (Flush)

Los siguientes valores son operaciones de vaciado válidas para flujos basados en Brotli:

zlib.constants.BROTLI_OPERATION_PROCESS (predeterminado para todas las operaciones)
zlib.constants.BROTLI_OPERATION_FLUSH (predeterminado al llamar a .flush())
zlib.constants.BROTLI_OPERATION_FINISH (predeterminado para el último fragmento)
zlib.constants.BROTLI_OPERATION_EMIT_METADATA
- Esta operación en particular puede ser difícil de usar en un contexto de Node.js, ya que la capa de transmisión dificulta saber qué datos terminarán en este marco. Además, actualmente no hay forma de consumir estos datos a través de la API de Node.js.

Opciones del compresor

Hay varias opciones que se pueden configurar en los codificadores de Brotli, que afectan la eficiencia de la compresión y la velocidad. Tanto las claves como los valores se pueden acceder como propiedades del objeto zlib.constants.

Las opciones más importantes son:

BROTLI_PARAM_MODE
- BROTLI_MODE_GENERIC (predeterminado)
- BROTLI_MODE_TEXT, ajustado para texto UTF-8
- BROTLI_MODE_FONT, ajustado para fuentes WOFF 2.0
BROTLI_PARAM_QUALITY
- Varía desde BROTLI_MIN_QUALITY hasta BROTLI_MAX_QUALITY, con un valor predeterminado de BROTLI_DEFAULT_QUALITY.
BROTLI_PARAM_SIZE_HINT
- Valor entero que representa el tamaño de entrada esperado; el valor predeterminado es 0 para un tamaño de entrada desconocido.

Las siguientes banderas se pueden establecer para un control avanzado sobre el algoritmo de compresión y el ajuste del uso de la memoria:

BROTLI_PARAM_LGWIN
- Varía desde BROTLI_MIN_WINDOW_BITS hasta BROTLI_MAX_WINDOW_BITS, con un valor predeterminado de BROTLI_DEFAULT_WINDOW, o hasta BROTLI_LARGE_MAX_WINDOW_BITS si la bandera BROTLI_PARAM_LARGE_WINDOW está establecida.
BROTLI_PARAM_LGBLOCK
- Varía desde BROTLI_MIN_INPUT_BLOCK_BITS hasta BROTLI_MAX_INPUT_BLOCK_BITS.
BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING
- Bandera booleana que disminuye la tasa de compresión en favor de la velocidad de descompresión.
BROTLI_PARAM_LARGE_WINDOW
- Bandera booleana que habilita el modo “Large Window Brotli” (no compatible con el formato Brotli estandarizado en RFC 7932).
BROTLI_PARAM_NPOSTFIX
- Varía de 0 a BROTLI_MAX_NPOSTFIX.
BROTLI_PARAM_NDIRECT
- Varía de 0 a 15 \<\< NPOSTFIX en pasos de 1 \<\< NPOSTFIX.

Opciones del descompresor

Estas opciones avanzadas están disponibles para controlar la descompresión:

BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION
- Bandera booleana que afecta los patrones internos de asignación de memoria.
BROTLI_DECODER_PARAM_LARGE_WINDOW
- Bandera booleana que habilita el modo “Large Window Brotli” (no compatible con el formato Brotli estandarizado en RFC 7932).

Clase: `Options`

[Historial]

Versión	Cambios
v14.5.0, v12.19.0	Ahora se admite la opción `maxOutputLength`.
v9.4.0	La opción `dictionary` puede ser un `ArrayBuffer`.
v8.0.0	La opción `dictionary` ahora puede ser un `Uint8Array`.
v5.11.0	Ahora se admite la opción `finishFlush`.
v0.11.1	Añadido en: v0.11.1

Cada clase basada en zlib toma un objeto options. No se requieren opciones.

Algunas opciones solo son relevantes cuando se comprime y las clases de descompresión las ignoran.

flush <integer> Predeterminado: zlib.constants.Z_NO_FLUSH
finishFlush <integer> Predeterminado: zlib.constants.Z_FINISH
chunkSize <integer> Predeterminado: 16 * 1024
windowBits <integer>
level <integer> (solo compresión)
memLevel <integer> (solo compresión)
strategy <integer> (solo compresión)
dictionary <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> (solo deflate/inflate, diccionario vacío por defecto)
info <boolean> (Si es true, devuelve un objeto con buffer y engine.)
maxOutputLength <integer> Limita el tamaño de salida cuando se usan métodos de conveniencia. Predeterminado: buffer.kMaxLength

Consulta la documentación de deflateInit2 e inflateInit2 para obtener más información.

Clase: `BrotliOptions`

[Historial]

Versión	Cambios
v14.5.0, v12.19.0	Ahora se admite la opción `maxOutputLength`.
v11.7.0	Añadido en: v11.7.0

Cada clase basada en Brotli toma un objeto options. Todas las opciones son opcionales.

flush <integer> Predeterminado: zlib.constants.BROTLI_OPERATION_PROCESS
finishFlush <integer> Predeterminado: zlib.constants.BROTLI_OPERATION_FINISH
chunkSize <integer> Predeterminado: 16 * 1024
params <Object> Objeto clave-valor que contiene parámetros Brotli indexados.
maxOutputLength <integer> Limita el tamaño de salida cuando se utilizan métodos de conveniencia. Predeterminado: buffer.kMaxLength

Por ejemplo:

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

Clase: `zlib.BrotliCompress`

Añadido en: v11.7.0, v10.16.0

Comprime datos utilizando el algoritmo Brotli.

Clase: `zlib.BrotliDecompress`

Añadido en: v11.7.0, v10.16.0

Descomprime datos utilizando el algoritmo Brotli.

Clase: `zlib.Deflate`

Añadido en: v0.5.8

Comprime datos utilizando deflate.

Clase: `zlib.DeflateRaw`

Añadido en: v0.5.8

Comprime datos utilizando deflate, y no añade un encabezado zlib.

Clase: `zlib.Gunzip`

[Historial]

Versión	Cambios
v6.0.0	La basura final al final del flujo de entrada ahora resultará en un evento `'error'`.
v5.9.0	Ahora se admiten varios miembros de archivos gzip concatenados.
v5.0.0	Un flujo de entrada truncado ahora resultará en un evento `'error'`.
v0.5.8	Añadido en: v0.5.8

Descomprime un flujo gzip.

Clase: `zlib.Gzip`

Añadido en: v0.5.8

Comprime datos utilizando gzip.

Clase: `zlib.Inflate`

[Historial]

Versión	Cambios
v5.0.0	Un flujo de entrada truncado ahora resultará en un evento `'error'`.
v0.5.8	Añadido en: v0.5.8

Descomprime un flujo deflate.

Clase: `zlib.InflateRaw`

[Historial]

Versión	Cambios
v6.8.0	Los diccionarios personalizados ahora son compatibles con `InflateRaw`.
v5.0.0	Un flujo de entrada truncado ahora resultará en un evento `'error'`.
v0.5.8	Añadido en: v0.5.8

Descomprime un flujo deflate sin procesar.

Clase: `zlib.Unzip`

Añadido en: v0.5.8

Descomprime un flujo comprimido con Gzip o Deflate mediante la detección automática de la cabecera.

Clase: `zlib.ZlibBase`

[Historial]

Versión	Cambios
v11.7.0, v10.16.0	Esta clase fue renombrada de `Zlib` a `ZlibBase`.
v0.5.8	Añadido en: v0.5.8

No es exportada por el módulo node:zlib. Se documenta aquí porque es la clase base de las clases de compresor/descompresor.

Esta clase hereda de stream.Transform, permitiendo que los objetos node:zlib sean utilizados en pipes y operaciones de flujo similares.

`zlib.bytesWritten`

Añadido en: v10.0.0

<number>

La propiedad zlib.bytesWritten especifica el número de bytes escritos en el motor, antes de que los bytes sean procesados (comprimidos o descomprimidos, según corresponda a la clase derivada).

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

Agregado en: v22.2.0, v20.15.0

data <string> | <Buffer> | <TypedArray> | <DataView> Cuando data es una cadena, se codificará como UTF-8 antes de utilizarse para el cálculo.
value <integer> Un valor inicial opcional. Debe ser un entero sin signo de 32 bits. Predeterminado: 0
Devuelve: <integer> Un entero sin signo de 32 bits que contiene la suma de comprobación.

Calcula una suma de comprobación de Comprobación de redundancia cíclica de 32 bits de data. Si se especifica value, se utiliza como valor inicial de la suma de comprobación, de lo contrario, se utiliza 0 como valor inicial.

El algoritmo CRC está diseñado para calcular sumas de comprobación y detectar errores en la transmisión de datos. No es adecuado para la autenticación criptográfica.

Para ser coherente con otras API, si los data son una cadena, se codificarán con UTF-8 antes de utilizarse para el cálculo. Si los usuarios solo utilizan Node.js para calcular y hacer coincidir las sumas de comprobación, esto funciona bien con otras API que utilizan la codificación UTF-8 de forma predeterminada.

Algunas bibliotecas de JavaScript de terceros calculan la suma de comprobación en una cadena basándose en str.charCodeAt() para que se pueda ejecutar en los navegadores. Si los usuarios quieren que coincida la suma de comprobación calculada con este tipo de biblioteca en el navegador, es mejor utilizar la misma biblioteca en Node.js si también se ejecuta en Node.js. Si los usuarios tienen que utilizar zlib.crc32() para que coincida la suma de comprobación producida por dicha biblioteca de terceros:

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

Agregado en: v0.9.4

callback <Function>

Cierra el controlador subyacente.

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

Agregado en: v0.5.8

kind Predeterminado: zlib.constants.Z_FULL_FLUSH para streams basados en zlib, zlib.constants.BROTLI_OPERATION_FLUSH para streams basados en Brotli.
callback <Function>

Vacía los datos pendientes. No llames a esto a la ligera, los vaciados prematuros impactan negativamente en la efectividad del algoritmo de compresión.

Llamar a esto solo vacía los datos del estado interno de zlib, y no realiza ningún tipo de vaciado a nivel de streams. Más bien, se comporta como una llamada normal a .write(), es decir, se pondrá en cola detrás de otras escrituras pendientes y solo producirá salida cuando se estén leyendo datos del stream.

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

Agregado en: v0.11.4

level <integer>
strategy <integer>
callback <Function>

Esta función solo está disponible para streams basados en zlib, es decir, no en Brotli.

Actualiza dinámicamente el nivel de compresión y la estrategia de compresión. Solo aplicable al algoritmo deflate.

`zlib.reset()`

Agregado en: v0.7.0

Restablece el compresor/descompresor a los valores predeterminados de fábrica. Solo aplicable a los algoritmos de inflado y desinflado.

`zlib.constants`

Agregado en: v7.0.0

Proporciona un objeto que enumera las constantes relacionadas con Zlib.

`zlib.createBrotliCompress([options])`

Agregado en: v11.7.0, v10.16.0

options <brotli options>

Crea y devuelve un nuevo objeto BrotliCompress.

`zlib.createBrotliDecompress([options])`

Agregado en: v11.7.0, v10.16.0

options <brotli options>

Crea y devuelve un nuevo objeto BrotliDecompress.

`zlib.createDeflate([options])`

Agregado en: v0.5.8

options <zlib options>

Crea y devuelve un nuevo objeto Deflate.

`zlib.createDeflateRaw([options])`

Agregado en: v0.5.8

options <zlib options>

Crea y devuelve un nuevo objeto DeflateRaw.

Una actualización de zlib de 1.2.8 a 1.2.11 cambió el comportamiento cuando windowBits se establece en 8 para los flujos deflate sin procesar. zlib establecería automáticamente windowBits en 9 si inicialmente se estableció en 8. Las versiones más recientes de zlib generarán una excepción, por lo que Node.js restauró el comportamiento original de actualizar un valor de 8 a 9, ya que pasar windowBits = 9 a zlib en realidad resulta en un flujo comprimido que utiliza efectivamente una ventana de 8 bits solamente.

`zlib.createGunzip([options])`

Agregado en: v0.5.8

options <zlib options>

Crea y devuelve un nuevo objeto Gunzip.

`zlib.createGzip([options])`

Agregado en: v0.5.8

options <zlib options>

Crea y devuelve un nuevo objeto Gzip. Ver ejemplo.

`zlib.createInflate([options])`

Agregado en: v0.5.8

options <zlib options>

Crea y devuelve un nuevo objeto Inflate.

`zlib.createInflateRaw([options])`

Agregado en: v0.5.8

options <zlib options>

Crea y devuelve un nuevo objeto InflateRaw.

`zlib.createUnzip([options])`

Agregado en: v0.5.8

options <zlib options>

Crea y devuelve un nuevo objeto Unzip.

Métodos de conveniencia

Todos estos toman un Buffer, TypedArray, DataView, ArrayBuffer o una cadena como primer argumento, un segundo argumento opcional para proporcionar opciones a las clases zlib y llamará a la devolución de llamada proporcionada con callback(error, result).

Cada método tiene una contraparte *Sync, que acepta los mismos argumentos, pero sin una devolución de llamada.

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

Agregado en: v11.7.0, v10.16.0

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

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

Agregado en: v11.7.0, v10.16.0

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

Comprime un fragmento de datos con BrotliCompress.

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

Agregado en: v11.7.0, v10.16.0

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

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

Agregado en: v11.7.0, v10.16.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opciones de brotli>

Descomprime un fragmento de datos con BrotliDecompress.

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` ahora puede ser un `Uint8Array`.
v0.6.0	Añadido en: v0.6.0

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

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` ahora puede ser un `Uint8Array`.
v0.11.12	Añadido en: v0.11.12

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opciones de zlib>

Comprime un fragmento de datos con Deflate.

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

[Historial]

Versión	Cambios
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` ahora puede ser un `Uint8Array`.
v0.6.0	Añadido en: v0.6.0

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

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` ahora puede ser un `Uint8Array`.
v0.11.12	Añadido en: v0.11.12

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opciones de zlib>

Comprime un fragmento de datos con DeflateRaw.

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` ahora puede ser un `Uint8Array`.
v0.6.0	Añadido en: v0.6.0

buffer <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>
options <opciones de zlib>
callback <Función>

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` ahora puede ser un `Uint8Array`.
v0.11.12	Agregado en: v0.11.12

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

Descomprime un fragmento de datos con Gunzip.

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` ahora puede ser un `Uint8Array`.
v0.6.0	Agregado en: v0.6.0

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

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` ahora puede ser un `Uint8Array`.
v0.11.12	Añadido en: v0.11.12

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

Comprime un fragmento de datos con Gzip.

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` ahora puede ser un `Uint8Array`.
v0.6.0	Añadido en: v0.6.0

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

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` puede ser un `Uint8Array` ahora.
v0.11.12	Añadido en: v0.11.12

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

Descomprime un fragmento de datos con Inflate.

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` puede ser un `Uint8Array` ahora.
v0.6.0	Añadido en: v0.6.0

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

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` ahora puede ser un `Uint8Array`.
v0.11.12	Agregado en: v0.11.12

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

Descomprime un fragmento de datos con InflateRaw.

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` ahora puede ser un `Uint8Array`.
v0.6.0	Agregado en: v0.6.0

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

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

[Historial]

Versión	Cambios
v9.4.0	El parámetro `buffer` puede ser un `ArrayBuffer`.
v8.0.0	El parámetro `buffer` puede ser cualquier `TypedArray` o `DataView`.
v8.0.0	El parámetro `buffer` ahora puede ser un `Uint8Array`.
v0.11.12	Añadido en: v0.11.12

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

Descomprime un fragmento de datos con Unzip.

Zlib ​

Uso del Threadpool y consideraciones de rendimiento ​

Comprimiendo peticiones y respuestas HTTP ​

Ajuste del uso de memoria ​

Para flujos basados en zlib ​

Para flujos basados en Brotli ​

Vaciado ​

Constantes ​

Constantes de zlib ​

Constantes de Brotli ​

Operaciones de vaciado (Flush) ​

Opciones del compresor ​

Opciones del descompresor ​

Clase: Options ​

Clase: BrotliOptions ​

Clase: zlib.BrotliCompress ​

Clase: zlib.BrotliDecompress ​

Clase: zlib.Deflate ​

Clase: zlib.DeflateRaw ​

Clase: zlib.Gunzip ​

Clase: zlib.Gzip ​

Clase: zlib.Inflate ​

Clase: zlib.InflateRaw ​

Clase: zlib.Unzip ​

Clase: 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 conveniencia ​

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 del Threadpool y consideraciones de rendimiento

Comprimiendo peticiones y respuestas HTTP

Ajuste del uso de memoria

Para flujos basados en zlib

Para flujos basados en Brotli

Vaciado

Constantes

Constantes de zlib

Constantes de Brotli

Operaciones de vaciado (Flush)

Opciones del compresor

Opciones del descompresor

Clase: `Options`

Clase: `BrotliOptions`

Clase: `zlib.BrotliCompress`

Clase: `zlib.BrotliDecompress`

Clase: `zlib.Deflate`

Clase: `zlib.DeflateRaw`

Clase: `zlib.Gunzip`

Clase: `zlib.Gzip`

Clase: `zlib.Inflate`

Clase: `zlib.InflateRaw`

Clase: `zlib.Unzip`

Clase: `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 conveniencia

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