Zlib

[Stable : 2 - Stable]

Source Code : lib/zlib.js

Le module node:zlib fournit des fonctionnalités de compression implémentées à l'aide de Gzip, Deflate/Inflate et Brotli.

Pour y accéder :

ESMCJS

import os from 'node:zlib'

const zlib = require('node:zlib')

La compression et la décompression sont basées sur l'API Streams de Node.js.

La compression ou la décompression d'un flux (comme un fichier) peut être réalisée en passant le flux source par un flux zlib Transform vers un flux de destination :

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, en utilisant l'API pipeline 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
})

Il est également possible de compresser ou de décompresser des données en une seule étape :

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

Utilisation du pool de threads et considérations de performance

Toutes les API zlib, sauf celles qui sont explicitement synchrones, utilisent le pool de threads interne de Node.js. Cela peut entraîner des effets surprenants et des limitations de performance dans certaines applications.

La création et l'utilisation simultanée d'un grand nombre d'objets zlib peuvent entraîner une fragmentation de la mémoire importante.

ESMCJS

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

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

// ATTENTION : NE FAITES PAS ÇA !
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')

// ATTENTION : NE FAITES PAS ÇA !
for (let i = 0; i < 30000; ++i) {
  zlib.deflate(payload, (err, buffer) => {})
}

Dans l'exemple précédent, 30 000 instances de deflate sont créées concurremment. En raison de la manière dont certains systèmes d'exploitation gèrent l'allocation et la désallocation de la mémoire, cela peut entraîner une fragmentation de la mémoire importante.

Il est fortement recommandé de mettre en cache les résultats des opérations de compression pour éviter les doublons.

Compression des requêtes et des réponses HTTP

Le module node:zlib peut être utilisé pour implémenter la prise en charge des mécanismes d'encodage de contenu gzip, deflate et br définis par HTTP.

L'en-tête HTTP Accept-Encoding est utilisé dans une requête HTTP pour identifier les encodages de compression acceptés par le client. L'en-tête Content-Encoding est utilisé pour identifier les encodages de compression réellement appliqués à un message.

Les exemples ci-dessous sont considérablement simplifiés pour montrer le concept de base. L'utilisation de l'encodage zlib peut être coûteuse, et les résultats doivent être mis en cache. Consultez Réglage de l'utilisation de la mémoire pour plus d'informations sur les compromis vitesse/mémoire/compression impliqués dans l'utilisation de zlib.

ESMCJS

// Exemple de requête client
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("Une erreur s'est produite :", err)
      process.exitCode = 1
    }
  }

  switch (response.headers['content-encoding']) {
    case 'br':
      pipeline(response, zlib.createBrotliDecompress(), output, onError)
      break
    // Ou, utilisez simplement zlib.createUnzip() pour gérer les deux cas suivants :
    case 'gzip':
      pipeline(response, zlib.createGunzip(), output, onError)
      break
    case 'deflate':
      pipeline(response, zlib.createInflate(), output, onError)
      break
    default:
      pipeline(response, output, onError)
      break
  }
})

// Exemple de requête client
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("Une erreur s'est produite :", err)
      process.exitCode = 1
    }
  }

  switch (response.headers['content-encoding']) {
    case 'br':
      pipeline(response, zlib.createBrotliDecompress(), output, onError)
      break
    // Ou, utilisez simplement zlib.createUnzip() pour gérer les deux cas suivants :
    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

// Exemple de serveur
// L'exécution d'une opération gzip à chaque requête est assez coûteuse.
// Il serait beaucoup plus efficace de mettre en cache le tampon compressé.
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')
    // Stockez une version compressée et une version non compressée de la ressource.
    response.setHeader('Vary', 'Accept-Encoding')
    const acceptEncoding = request.headers['accept-encoding'] || ''

    const onError = err => {
      if (err) {
        // Si une erreur se produit, il n'y a pas grand-chose que nous puissions faire car
        // le serveur a déjà envoyé le code de réponse 200 et
        // une certaine quantité de données a déjà été envoyée au client.
        // Le mieux que nous puissions faire est de terminer la réponse immédiatement
        // et de consigner l'erreur.
        response.end()
        console.error("Une erreur s'est produite :", err)
      }
    }

    // Remarque : il ne s'agit pas d'un analyseur accept-encoding conforme.
    // Voir 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)

// Exemple de serveur
// L'exécution d'une opération gzip à chaque requête est assez coûteuse.
// Il serait beaucoup plus efficace de mettre en cache le tampon compressé.
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')
    // Stockez une version compressée et une version non compressée de la ressource.
    response.setHeader('Vary', 'Accept-Encoding')
    const acceptEncoding = request.headers['accept-encoding'] || ''

    const onError = err => {
      if (err) {
        // Si une erreur se produit, il n'y a pas grand-chose que nous puissions faire car
        // le serveur a déjà envoyé le code de réponse 200 et
        // une certaine quantité de données a déjà été envoyée au client.
        // Le mieux que nous puissions faire est de terminer la réponse immédiatement
        // et de consigner l'erreur.
        response.end()
        console.error("Une erreur s'est produite :", err)
      }
    }

    // Remarque : il ne s'agit pas d'un analyseur accept-encoding conforme.
    // Voir 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)

Par défaut, les méthodes zlib lèvent une erreur lors de la décompression de données tronquées. Cependant, s'il est connu que les données sont incomplètes, ou si le souhait est d'inspecter uniquement le début d'un fichier compressé, il est possible de supprimer la gestion des erreurs par défaut en modifiant la méthode de vidage utilisée pour décompresser le dernier bloc de données d'entrée :

// Il s'agit d'une version tronquée du tampon des exemples ci-dessus
const buffer = Buffer.from('eJzT0yMA', 'base64')

zlib.unzip(
  buffer,
  // Pour Brotli, l'équivalent est zlib.constants.BROTLI_OPERATION_FLUSH.
  { finishFlush: zlib.constants.Z_SYNC_FLUSH },
  (err, buffer) => {
    if (err) {
      console.error("Une erreur s'est produite :", err)
      process.exitCode = 1
    }
    console.log(buffer.toString())
  }
)

Cela ne modifiera pas le comportement dans d'autres situations de levée d'erreurs, par exemple lorsque les données d'entrée ont un format non valide. En utilisant cette méthode, il ne sera pas possible de déterminer si l'entrée s'est terminée prématurément ou si elle manque les contrôles d'intégrité, ce qui rend nécessaire de vérifier manuellement que le résultat décompressé est valide.

Réglage de l'utilisation de la mémoire

Pour les flux basés sur zlib

De zlib/zconf.h, modifié pour l'utilisation de Node.js :

Les besoins en mémoire pour deflate sont (en octets) :

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

C'est-à-dire : 128 Ko pour windowBits = 15 + 128 Ko pour memLevel = 8 (valeurs par défaut) plus quelques kilo-octets pour les petits objets.

Par exemple, pour réduire les besoins en mémoire par défaut de 256 Ko à 128 Ko, les options doivent être définies sur :

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

Cela entraînera cependant généralement une dégradation de la compression.

Les besoins en mémoire pour inflate sont (en octets) 1 \<\< windowBits. C'est-à-dire 32 Ko pour windowBits = 15 (valeur par défaut) plus quelques kilo-octets pour les petits objets.

Ceci s'ajoute à un seul tampon de bloc de sortie interne de taille chunkSize, qui vaut par défaut 16 Ko.

La vitesse de compression zlib est affectée de manière la plus spectaculaire par le paramètre level. Un niveau supérieur entraînera une meilleure compression, mais prendra plus de temps. Un niveau inférieur entraînera une compression moindre, mais sera beaucoup plus rapide.

En général, des options d'utilisation de la mémoire plus importantes signifient que Node.js doit effectuer moins d'appels à zlib car il pourra traiter plus de données à chaque opération write. C'est donc un autre facteur qui affecte la vitesse, au prix de l'utilisation de la mémoire.

Pour les flux basés sur Brotli

Il existe des équivalents aux options zlib pour les flux basés sur Brotli, bien que ces options aient des plages différentes de celles de zlib :

L'option level de zlib correspond à l'option BROTLI_PARAM_QUALITY de Brotli.
L'option windowBits de zlib correspond à l'option BROTLI_PARAM_LGWIN de Brotli.

Voir ci-dessous pour plus de détails sur les options spécifiques à Brotli.

Vidage

Appeler .flush() sur un flux de compression fera en sorte que zlib renvoie autant de sortie que possible actuellement. Cela peut se faire au prix d'une qualité de compression dégradée, mais cela peut être utile lorsque les données doivent être disponibles dès que possible.

Dans l'exemple suivant, flush() est utilisé pour écrire une réponse HTTP partielle compressée au client :

ESMCJS

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

http
  .createServer((request, response) => {
    // Pour simplifier, les vérifications Accept-Encoding sont omises.
    response.writeHead(200, { 'content-encoding': 'gzip' })
    const output = zlib.createGzip()
    let i

    pipeline(output, response, err => {
      if (err) {
        // Si une erreur se produit, nous ne pouvons pas faire grand-chose car
        // le serveur a déjà envoyé le code de réponse 200 et
        // une certaine quantité de données a déjà été envoyée au client.
        // Le mieux que nous puissions faire est de terminer la réponse immédiatement
        // et de consigner l'erreur.
        clearInterval(i)
        response.end()
        console.error("Une erreur s'est produite :", err)
      }
    })

    i = setInterval(() => {
      output.write(`L'heure actuelle est ${Date()}\n`, () => {
        // Les données ont été transmises à zlib, mais l'algorithme de compression peut
        // avoir décidé de mettre les données en mémoire tampon pour une compression plus efficace.
        // L'appel à .flush() rendra les données disponibles dès que le client
        // sera prêt à les recevoir.
        output.flush()
      })
    }, 1000)
  })
  .listen(1337)

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

http
  .createServer((request, response) => {
    // Pour simplifier, les vérifications Accept-Encoding sont omises.
    response.writeHead(200, { 'content-encoding': 'gzip' })
    const output = zlib.createGzip()
    let i

    pipeline(output, response, err => {
      if (err) {
        // Si une erreur se produit, nous ne pouvons pas faire grand-chose car
        // le serveur a déjà envoyé le code de réponse 200 et
        // une certaine quantité de données a déjà été envoyée au client.
        // Le mieux que nous puissions faire est de terminer la réponse immédiatement
        // et de consigner l'erreur.
        clearInterval(i)
        response.end()
        console.error("Une erreur s'est produite :", err)
      }
    })

    i = setInterval(() => {
      output.write(`L'heure actuelle est ${Date()}\n`, () => {
        // Les données ont été transmises à zlib, mais l'algorithme de compression peut
        // avoir décidé de mettre les données en mémoire tampon pour une compression plus efficace.
        // L'appel à .flush() rendra les données disponibles dès que le client
        // sera prêt à les recevoir.
        output.flush()
      })
    }, 1000)
  })
  .listen(1337)

Constantes

Ajouté dans : v0.5.8

Constantes zlib

Toutes les constantes définies dans zlib.h sont également définies sur require('node:zlib').constants. Normalement, il ne sera pas nécessaire d'utiliser ces constantes. Elles sont documentées afin que leur présence ne soit pas surprenante. Cette section est reprise presque directement de la documentation zlib.

Auparavant, les constantes étaient directement accessibles depuis require('node:zlib'), par exemple zlib.Z_NO_FLUSH. L'accès direct aux constantes depuis le module est actuellement toujours possible, mais il est déprécié.

Valeurs de vidage autorisées.

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

Codes de retour pour les fonctions de compression/décompression. Les valeurs négatives sont des erreurs, les valeurs positives sont utilisées pour des événements spéciaux mais normaux.

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

Niveaux de compression.

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

Stratégie de compression.

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

Constantes Brotli

Ajouté dans : v11.7.0, v10.16.0

Plusieurs options et autres constantes sont disponibles pour les flux basés sur Brotli :

Opérations de vidage

Les valeurs suivantes sont des opérations de vidage valides pour les flux basés sur Brotli :

zlib.constants.BROTLI_OPERATION_PROCESS (par défaut pour toutes les opérations)
zlib.constants.BROTLI_OPERATION_FLUSH (par défaut lors de l'appel de .flush())
zlib.constants.BROTLI_OPERATION_FINISH (par défaut pour le dernier bloc)
zlib.constants.BROTLI_OPERATION_EMIT_METADATA
- Cette opération particulière peut être difficile à utiliser dans un contexte Node.js, car la couche de streaming rend difficile de savoir quelles données finiront dans cette trame. De plus, il n'y a actuellement aucun moyen de consommer ces données via l'API Node.js.

Options de compression

Plusieurs options peuvent être définies sur les encodeurs Brotli, affectant l'efficacité et la vitesse de compression. Les clés et les valeurs sont accessibles en tant que propriétés de l'objet zlib.constants.

Les options les plus importantes sont :

BROTLI_PARAM_MODE
- BROTLI_MODE_GENERIC (par défaut)
- BROTLI_MODE_TEXT, ajusté pour le texte UTF-8
- BROTLI_MODE_FONT, ajusté pour les polices WOFF 2.0
BROTLI_PARAM_QUALITY
- Varie de BROTLI_MIN_QUALITY à BROTLI_MAX_QUALITY, avec une valeur par défaut de BROTLI_DEFAULT_QUALITY.
BROTLI_PARAM_SIZE_HINT
- Valeur entière représentant la taille d'entrée attendue ; la valeur par défaut est 0 pour une taille d'entrée inconnue.

Les indicateurs suivants peuvent être définis pour un contrôle avancé de l'algorithme de compression et de l'optimisation de l'utilisation de la mémoire :

BROTLI_PARAM_LGWIN
- Varie de BROTLI_MIN_WINDOW_BITS à BROTLI_MAX_WINDOW_BITS, avec une valeur par défaut de BROTLI_DEFAULT_WINDOW, ou jusqu'à BROTLI_LARGE_MAX_WINDOW_BITS si l'indicateur BROTLI_PARAM_LARGE_WINDOW est défini.
BROTLI_PARAM_LGBLOCK
- Varie de BROTLI_MIN_INPUT_BLOCK_BITS à BROTLI_MAX_INPUT_BLOCK_BITS.
BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING
- Indicateur booléen qui diminue le taux de compression au profit de la vitesse de décompression.
BROTLI_PARAM_LARGE_WINDOW
- Indicateur booléen activant le mode « Large Window Brotli » (non compatible avec le format Brotli tel que normalisé dans la RFC 7932).
BROTLI_PARAM_NPOSTFIX
- Varie de 0 à BROTLI_MAX_NPOSTFIX.
BROTLI_PARAM_NDIRECT
- Varie de 0 à 15 \<\< NPOSTFIX par pas de 1 \<\< NPOSTFIX.

Options de décompression

Ces options avancées sont disponibles pour contrôler la décompression :

BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION
- Indicateur booléen qui affecte les schémas d'allocation de mémoire interne.
BROTLI_DECODER_PARAM_LARGE_WINDOW
- Indicateur booléen activant le mode « Large Window Brotli » (non compatible avec le format Brotli tel que normalisé dans la RFC 7932).

Classe : `Options`

[Historique]

Version	Modifications
v14.5.0, v12.19.0	L'option `maxOutputLength` est désormais prise en charge.
v9.4.0	L'option `dictionary` peut être un `ArrayBuffer`.
v8.0.0	L'option `dictionary` peut désormais être un `Uint8Array`.
v5.11.0	L'option `finishFlush` est désormais prise en charge.
v0.11.1	Ajoutée dans : v0.11.1

Chaque classe basée sur zlib prend un objet options. Aucune option n'est requise.

Certaines options ne sont pertinentes que lors de la compression et sont ignorées par les classes de décompression.

flush <entier> Défaut : zlib.constants.Z_NO_FLUSH
finishFlush <entier> Défaut : zlib.constants.Z_FINISH
chunkSize <entier> Défaut : 16 * 1024
windowBits <entier>
level <entier> (compression uniquement)
memLevel <entier> (compression uniquement)
strategy <entier> (compression uniquement)
dictionary <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> (deflate/inflate uniquement, dictionnaire vide par défaut)
info <booléen> (Si true, renvoie un objet avec buffer et engine.)
maxOutputLength <entier> Limite la taille de sortie lors de l'utilisation des méthodes de commodité. Défaut : buffer.kMaxLength

Voir la documentation deflateInit2 et inflateInit2 pour plus d'informations.

Classe : `BrotliOptions`

[Historique]

Version	Modifications
v14.5.0, v12.19.0	L'option `maxOutputLength` est désormais prise en charge.
v11.7.0	Ajoutée dans : v11.7.0

Chaque classe basée sur Brotli prend un objet options. Toutes les options sont facultatives.

flush <entier> Défaut : zlib.constants.BROTLI_OPERATION_PROCESS
finishFlush <entier> Défaut : zlib.constants.BROTLI_OPERATION_FINISH
chunkSize <entier> Défaut : 16 * 1024
params <Objet> Objet clé-valeur contenant les paramètres Brotli indexés.
maxOutputLength <entier> Limite la taille de la sortie lors de l'utilisation des méthodes de commodité. Défaut : buffer.kMaxLength

Par exemple :

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

Classe : `zlib.BrotliCompress`

Ajouté dans : v11.7.0, v10.16.0

Compresse les données à l'aide de l'algorithme Brotli.

Classe : `zlib.BrotliDecompress`

Ajouté dans : v11.7.0, v10.16.0

Décompresse les données à l'aide de l'algorithme Brotli.

Classe : `zlib.Deflate`

Ajouté dans : v0.5.8

Compresse les données à l'aide de deflate.

Classe : `zlib.DeflateRaw`

Ajouté dans : v0.5.8

Compresse les données à l'aide de deflate, et n'ajoute pas d'en-tête zlib.

Classe : `zlib.Gunzip`

[Historique]

Version	Modifications
v6.0.0	Les données inutiles à la fin du flux d'entrée entraîneront désormais un événement `'error'`.
v5.9.0	Plusieurs membres de fichiers gzip concaténés sont désormais pris en charge.
v5.0.0	Un flux d'entrée tronqué entraînera désormais un événement `'error'`.
v0.5.8	Ajouté dans : v0.5.8

Décompresse un flux gzip.

Classe : `zlib.Gzip`

Ajouté dans : v0.5.8

Compresse les données à l'aide de gzip.

Classe : `zlib.Inflate`

[Historique]

Version	Modifications
v5.0.0	Un flux d'entrée tronqué entraînera désormais un événement `'error'`
v0.5.8	Ajouté dans : v0.5.8

Décompresse un flux deflate.

Classe : `zlib.InflateRaw`

[Historique]

Version	Modifications
v6.8.0	Les dictionnaires personnalisés sont désormais pris en charge par `InflateRaw`.
v5.0.0	Un flux d'entrée tronqué entraînera désormais un événement `'error'`
v0.5.8	Ajouté dans : v0.5.8

Décompresse un flux deflate brut.

Classe : `zlib.Unzip`

Ajouté dans : v0.5.8

Décompresse un flux compressé Gzip ou Deflate en détectant automatiquement l'en-tête.

Classe : `zlib.ZlibBase`

[Historique]

Version	Modifications
v11.7.0, v10.16.0	Cette classe a été renommée de `Zlib` en `ZlibBase`.
v0.5.8	Ajouté dans : v0.5.8

N'est pas exporté par le module node:zlib. Il est documenté ici car il s'agit de la classe de base des classes de compresseur/décompresseur.

Cette classe hérite de stream.Transform, permettant aux objets node:zlib d'être utilisés dans les pipelines et les opérations de flux similaires.

`zlib.bytesWritten`

Ajouté dans : v10.0.0

<nombre>

La propriété zlib.bytesWritten spécifie le nombre d'octets écrits dans le moteur, avant que les octets ne soient traités (compressés ou décompressés, selon le cas pour la classe dérivée).

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

Ajouté dans : v22.2.0, v20.15.0

data <chaîne de caractères> | <Buffer> | <TypedArray> | <DataView> Lorsque data est une chaîne de caractères, elle sera encodée en UTF-8 avant d'être utilisée pour le calcul.
value <entier> Une valeur de départ facultative. Elle doit être un entier non signé sur 32 bits. Défaut : 0
Retourne : <entier> Un entier non signé sur 32 bits contenant la somme de contrôle.

Calcule une somme de contrôle CRC32 (Cyclic Redundancy Check) sur 32 bits de data. Si value est spécifié, il est utilisé comme valeur de départ de la somme de contrôle, sinon, 0 est utilisé comme valeur de départ.

L'algorithme CRC est conçu pour calculer des sommes de contrôle et détecter les erreurs dans la transmission de données. Il n'est pas adapté à l'authentification cryptographique.

Pour être cohérent avec les autres API, si data est une chaîne de caractères, elle sera encodée avec UTF-8 avant d'être utilisée pour le calcul. Si les utilisateurs utilisent uniquement Node.js pour calculer et faire correspondre les sommes de contrôle, cela fonctionne bien avec les autres API qui utilisent l'encodage UTF-8 par défaut.

Certaines bibliothèques JavaScript tierces calculent la somme de contrôle sur une chaîne de caractères basée sur str.charCodeAt() afin qu'elle puisse être exécutée dans les navigateurs. Si les utilisateurs souhaitent faire correspondre la somme de contrôle calculée avec ce type de bibliothèque dans le navigateur, il est préférable d'utiliser la même bibliothèque dans Node.js si elle s'exécute également dans Node.js. Si les utilisateurs doivent utiliser zlib.crc32() pour faire correspondre la somme de contrôle produite par une telle bibliothèque tierce :

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

Ajouté dans : v0.9.4

callback <Fonction>

Ferme le handle sous-jacent.

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

Ajouté dans : v0.5.8

kind Par défaut : zlib.constants.Z_FULL_FLUSH pour les flux basés sur zlib, zlib.constants.BROTLI_OPERATION_FLUSH pour les flux basés sur Brotli.
callback <Fonction>

Vide les données en attente. N'appelez pas cela à la légère, des vidages prématurés ont un impact négatif sur l'efficacité de l'algorithme de compression.

Cet appel ne vide les données que de l'état interne zlib, et n'effectue aucun vidage au niveau des flux. Au lieu de cela, il se comporte comme un appel normal à .write(), c'est-à-dire qu'il sera mis en file d'attente derrière d'autres écritures en attente et ne produira de sortie que lorsque des données sont lues à partir du flux.

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

Ajouté dans : v0.11.4

level <entier>
strategy <entier>
callback <Fonction>

Cette fonction est uniquement disponible pour les flux basés sur zlib, c'est-à-dire pas Brotli.

Met à jour dynamiquement le niveau de compression et la stratégie de compression. Applicable uniquement à l'algorithme deflate.

`zlib.reset()`

Ajouté dans : v0.7.0

Réinitialise le compresseur/décompresseur aux paramètres d'usine. Applicable uniquement aux algorithmes inflate et deflate.

`zlib.constants`

Ajouté dans : v7.0.0

Fournit un objet énumérant les constantes liées à Zlib.

`zlib.createBrotliCompress([options])`

Ajouté dans : v11.7.0, v10.16.0

options <options Brotli>

Crée et renvoie un nouvel objet BrotliCompress.

`zlib.createBrotliDecompress([options])`

Ajouté dans : v11.7.0, v10.16.0

options <options Brotli>

Crée et renvoie un nouvel objet BrotliDecompress.

`zlib.createDeflate([options])`

Ajouté dans : v0.5.8

options <options zlib>

Crée et renvoie un nouvel objet Deflate.

`zlib.createDeflateRaw([options])`

Ajouté dans : v0.5.8

options <options zlib>

Crée et renvoie un nouvel objet DeflateRaw.

Une mise à niveau de zlib de 1.2.8 à 1.2.11 a modifié le comportement lorsque windowBits est défini sur 8 pour les flux de décompression raw. zlib définissait automatiquement windowBits sur 9 s'il était initialement défini sur 8. Les versions plus récentes de zlib lèveront une exception, donc Node.js a restauré le comportement d'origine consistant à mettre à niveau une valeur de 8 à 9, car passer windowBits = 9 à zlib donne en fait un flux compressé qui utilise effectivement une fenêtre de 8 bits seulement.

`zlib.createGunzip([options])`

Ajouté dans : v0.5.8

options <options zlib>

Crée et renvoie un nouvel objet Gunzip.

`zlib.createGzip([options])`

Ajouté dans : v0.5.8

options <options zlib>

Crée et renvoie un nouvel objet Gzip. Voir exemple.

`zlib.createInflate([options])`

Ajouté dans : v0.5.8

options <options zlib>

Crée et renvoie un nouvel objet Inflate.

`zlib.createInflateRaw([options])`

Ajouté dans : v0.5.8

options <options zlib>

Crée et renvoie un nouvel objet InflateRaw.

`zlib.createUnzip([options])`

Ajouté dans : v0.5.8

options <options zlib>

Crée et renvoie un nouvel objet Unzip.

Méthodes de commodité

Toutes ces méthodes prennent un Buffer, un TypedArray, un DataView, un ArrayBuffer ou une chaîne de caractères comme premier argument, un deuxième argument optionnel pour fournir des options aux classes zlib, et appellent la fonction de rappel fournie avec callback(error, result).

Chaque méthode possède une contrepartie *Sync, qui accepte les mêmes arguments, mais sans fonction de rappel.

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

Ajouté dans : v11.7.0, v10.16.0

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

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

Ajouté dans : v11.7.0, v10.16.0

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

Compresser un bloc de données avec BrotliCompress.

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

Ajouté dans : v11.7.0, v10.16.0

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

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

Ajouté dans : v11.7.0, v10.16.0

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

Décompressez un bloc de données avec BrotliDecompress.

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.6.0	Ajouté dans : v0.6.0

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

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.11.12	Ajouté dans : v0.11.12

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

Compresse un bloc de données avec Deflate.

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

[Historique]

Version	Modifications
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.6.0	Ajouté dans : v0.6.0

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

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.11.12	Ajouté dans : v0.11.12

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

Compresse un bloc de données avec DeflateRaw.

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.6.0	Ajouté dans : v0.6.0

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

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.11.12	Ajouté dans : v0.11.12

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

Décompresse un bloc de données avec Gunzip.

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.6.0	Ajouté dans : v0.6.0

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

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.11.12	Ajouté dans : v0.11.12

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

Compresser un bloc de données avec Gzip.

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.6.0	Ajouté dans : v0.6.0

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

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.11.12	Ajouté dans : v0.11.12

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

Décompresser un bloc de données avec Inflate.

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.6.0	Ajouté dans : v0.6.0

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

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.11.12	Ajouté dans : v0.11.12

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

Décompresse un bloc de données avec InflateRaw.

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.6.0	Ajouté dans : v0.6.0

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

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

[Historique]

Version	Modifications
v9.4.0	Le paramètre `buffer` peut être un `ArrayBuffer`.
v8.0.0	Le paramètre `buffer` peut être n'importe quel `TypedArray` ou `DataView`.
v8.0.0	Le paramètre `buffer` peut maintenant être un `Uint8Array`.
v0.11.12	Ajouté dans la version : v0.11.12

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

Décompresse un bloc de données avec Unzip.

Zlib ​

Utilisation du pool de threads et considérations de performance ​

Compression des requêtes et des réponses HTTP ​

Réglage de l'utilisation de la mémoire ​

Pour les flux basés sur zlib ​

Pour les flux basés sur Brotli ​

Vidage ​

Constantes ​

Constantes zlib ​

Constantes Brotli ​

Opérations de vidage ​

Options de compression ​

Options de décompression ​

Classe : Options ​

Classe : BrotliOptions ​

Classe : zlib.BrotliCompress ​

Classe : zlib.BrotliDecompress ​

Classe : zlib.Deflate ​

Classe : zlib.DeflateRaw ​

Classe : 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éthodes de commodité ​

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

Utilisation du pool de threads et considérations de performance

Compression des requêtes et des réponses HTTP

Réglage de l'utilisation de la mémoire

Pour les flux basés sur zlib

Pour les flux basés sur Brotli

Vidage

Constantes

Constantes zlib

Constantes Brotli

Opérations de vidage

Options de compression

Options de décompression

Classe : `Options`

Classe : `BrotliOptions`

Classe : `zlib.BrotliCompress`

Classe : `zlib.BrotliDecompress`

Classe : `zlib.Deflate`

Classe : `zlib.DeflateRaw`

Classe : `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éthodes de commodité

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