Zlib
[Stabil: 2 - Stabil]
Stabil: 2 Stabilität: 2 - Stabil
Quellcode: lib/zlib.js
Das Modul node:zlib bietet Komprimierungsfunktionen, die mit Gzip, Deflate/Inflate und Brotli implementiert wurden.
Um darauf zuzugreifen:
import os from 'node:zlib'const zlib = require('node:zlib')Komprimierung und Dekomprimierung basieren auf der Node.js Streams API.
Das Komprimieren oder Dekomprimieren eines Streams (z. B. einer Datei) kann erreicht werden, indem der Quellstream über einen zlib-Transform-Stream in einen Zielstream geleitet wird:
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('Ein Fehler ist aufgetreten:', 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('Ein Fehler ist aufgetreten:', err)
process.exitCode = 1
}
})Oder, mit der Promise pipeline-API:
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('Ein Fehler ist aufgetreten:', err)
process.exitCode = 1
})Es ist auch möglich, Daten in einem einzigen Schritt zu komprimieren oder zu dekomprimieren:
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('Ein Fehler ist aufgetreten:', err)
process.exitCode = 1
}
console.log(buffer.toString('base64'))
})
const buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64')
unzip(buffer, (err, buffer) => {
if (err) {
console.error('Ein Fehler ist aufgetreten:', err)
process.exitCode = 1
}
console.log(buffer.toString())
})
// Oder, 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('Ein Fehler ist aufgetreten:', err)
process.exitCode = 1
}
console.log(buffer.toString('base64'))
})
const buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64')
unzip(buffer, (err, buffer) => {
if (err) {
console.error('Ein Fehler ist aufgetreten:', err)
process.exitCode = 1
}
console.log(buffer.toString())
})
// Oder, Promisified
const { promisify } = require('node:util')
const do_unzip = promisify(unzip)
do_unzip(buffer)
.then(buf => console.log(buf.toString()))
.catch(err => {
console.error('Ein Fehler ist aufgetreten:', err)
process.exitCode = 1
})Threadpool-Nutzung und Leistungsüberlegungen
Alle zlib-APIs, mit Ausnahme der explizit synchronen, verwenden den internen Threadpool von Node.js. Dies kann in einigen Anwendungen zu überraschenden Effekten und Leistungseinschränkungen führen.
Das gleichzeitige Erstellen und Verwenden einer großen Anzahl von zlib-Objekten kann zu einer erheblichen Speicherfragmentierung führen.
import zlib from 'node:zlib'
import { Buffer } from 'node:buffer'
const payload = Buffer.from('Dies sind einige Daten')
// WARNUNG: DIES NICHT TUN!
for (let i = 0; i < 30000; ++i) {
zlib.deflate(payload, (err, buffer) => {})
}const zlib = require('node:zlib')
const payload = Buffer.from('Dies sind einige Daten')
// WARNUNG: DIES NICHT TUN!
for (let i = 0; i < 30000; ++i) {
zlib.deflate(payload, (err, buffer) => {})
}Im vorangegangenen Beispiel werden 30.000 Deflate-Instanzen gleichzeitig erstellt. Aufgrund der Art und Weise, wie einige Betriebssysteme Speicherzuweisung und -freigabe handhaben, kann dies zu einer erheblichen Speicherfragmentierung führen.
Es wird dringend empfohlen, die Ergebnisse von Komprimierungsoperationen zu cachen, um Doppelarbeit zu vermeiden.
Komprimieren von HTTP-Anfragen und -Antworten
Das Modul node:zlib kann verwendet werden, um die Unterstützung für die von HTTP definierten Content-Encoding-Mechanismen gzip, deflate und br zu implementieren.
Der HTTP Accept-Encoding-Header wird innerhalb einer HTTP-Anfrage verwendet, um die vom Client akzeptierten Komprimierungs-Encodings zu identifizieren. Der Content-Encoding-Header wird verwendet, um die tatsächlich auf eine Nachricht angewendeten Komprimierungs-Encodings zu identifizieren.
Die unten angegebenen Beispiele sind drastisch vereinfacht, um das grundlegende Konzept zu zeigen. Die Verwendung der zlib-Kodierung kann teuer sein, und die Ergebnisse sollten zwischengespeichert werden. Siehe Optimierung der Speichernutzung für weitere Informationen zu den Geschwindigkeits-/Speicher-/Komprimierungs-Kompromissen, die mit der zlib-Nutzung verbunden sind.
// Beispiel für eine Client-Anfrage
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('Ein Fehler ist aufgetreten:', err)
process.exitCode = 1
}
}
switch (response.headers['content-encoding']) {
case 'br':
pipeline(response, zlib.createBrotliDecompress(), output, onError)
break
// Oder verwenden Sie einfach zlib.createUnzip(), um beide folgenden Fälle zu behandeln:
case 'gzip':
pipeline(response, zlib.createGunzip(), output, onError)
break
case 'deflate':
pipeline(response, zlib.createInflate(), output, onError)
break
default:
pipeline(response, output, onError)
break
}
})// Beispiel für eine Client-Anfrage
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('Ein Fehler ist aufgetreten:', err)
process.exitCode = 1
}
}
switch (response.headers['content-encoding']) {
case 'br':
pipeline(response, zlib.createBrotliDecompress(), output, onError)
break
// Oder verwenden Sie einfach zlib.createUnzip(), um beide folgenden Fälle zu behandeln:
case 'gzip':
pipeline(response, zlib.createGunzip(), output, onError)
break
case 'deflate':
pipeline(response, zlib.createInflate(), output, onError)
break
default:
pipeline(response, output, onError)
break
}
})// Beispiel für einen Server
// Das Ausführen einer Gzip-Operation bei jeder Anfrage ist ziemlich aufwändig.
// Es wäre viel effizienter, den komprimierten Puffer zu cachen.
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')
// Speichern Sie sowohl eine komprimierte als auch eine unkomprimierte Version der Ressource.
response.setHeader('Vary', 'Accept-Encoding')
const acceptEncoding = request.headers['accept-encoding'] || ''
const onError = err => {
if (err) {
// Wenn ein Fehler auftritt, können wir nicht viel tun, da
// der Server bereits den 200-Antwortcode gesendet hat und
// bereits eine bestimmte Datenmenge an den Client gesendet wurde.
// Das Beste, was wir tun können, ist, die Antwort sofort zu beenden
// und den Fehler zu protokollieren.
response.end()
console.error('Ein Fehler ist aufgetreten:', err)
}
}
// Hinweis: Dies ist kein konformer Accept-Encoding-Parser.
// Siehe 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)// Beispiel für einen Server
// Das Ausführen einer Gzip-Operation bei jeder Anfrage ist ziemlich aufwändig.
// Es wäre viel effizienter, den komprimierten Puffer zu cachen.
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')
// Speichern Sie sowohl eine komprimierte als auch eine unkomprimierte Version der Ressource.
response.setHeader('Vary', 'Accept-Encoding')
const acceptEncoding = request.headers['accept-encoding'] || ''
const onError = err => {
if (err) {
// Wenn ein Fehler auftritt, können wir nicht viel tun, da
// der Server bereits den 200-Antwortcode gesendet hat und
// bereits eine bestimmte Datenmenge an den Client gesendet wurde.
// Das Beste, was wir tun können, ist, die Antwort sofort zu beenden
// und den Fehler zu protokollieren.
response.end()
console.error('Ein Fehler ist aufgetreten:', err)
}
}
// Hinweis: Dies ist kein konformer Accept-Encoding-Parser.
// Siehe 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)Standardmäßig geben die zlib-Methoden einen Fehler aus, wenn sie gekürzte Daten dekomprimieren. Wenn jedoch bekannt ist, dass die Daten unvollständig sind oder der Wunsch besteht, nur den Anfang einer komprimierten Datei zu inspizieren, ist es möglich, die Standardfehlerbehandlung zu unterdrücken, indem die Flushing-Methode geändert wird, die zum Dekomprimieren des letzten Eingabedatenchunks verwendet wird:
// Dies ist eine gekürzte Version des Puffers aus den obigen Beispielen
const buffer = Buffer.from('eJzT0yMA', 'base64')
zlib.unzip(
buffer,
// Für Brotli ist das Äquivalent zlib.constants.BROTLI_OPERATION_FLUSH.
{ finishFlush: zlib.constants.Z_SYNC_FLUSH },
(err, buffer) => {
if (err) {
console.error('Ein Fehler ist aufgetreten:', err)
process.exitCode = 1
}
console.log(buffer.toString())
}
)Dies ändert das Verhalten in anderen fehlerverursachenden Situationen nicht, z. B. wenn die Eingabedaten ein ungültiges Format haben. Bei Verwendung dieser Methode ist es nicht möglich festzustellen, ob die Eingabe vorzeitig beendet wurde oder die Integritätsprüfungen fehlen, sodass manuell überprüft werden muss, ob das dekomprimierte Ergebnis gültig ist.
Speicherverbrauch optimieren
Für zlib-basierte Streams
Aus zlib/zconf.h, modifiziert für die Nutzung mit Node.js:
Der Speicherbedarf für Deflate beträgt (in Bytes):
;(1 << (windowBits + 2)) + (1 << (memLevel + 9))Das sind: 128 KB für windowBits = 15 + 128 KB für memLevel = 8 (Standardwerte) plus einige Kilobyte für kleine Objekte.
Um beispielsweise den Standard-Speicherbedarf von 256 KB auf 128 KB zu reduzieren, sollten die Optionen wie folgt eingestellt werden:
const options = { windowBits: 14, memLevel: 7 }Dies wird jedoch im Allgemeinen die Kompression verschlechtern.
Der Speicherbedarf für Inflate beträgt (in Bytes) 1 \<\< windowBits. Das sind 32 KB für windowBits = 15 (Standardwert) plus einige Kilobyte für kleine Objekte.
Dies kommt zusätzlich zu einem einzigen internen Ausgabepuffer der Größe chunkSize hinzu, der standardmäßig 16 KB beträgt.
Die Geschwindigkeit der zlib-Komprimierung wird am stärksten durch die Einstellung level beeinflusst. Ein höheres Level führt zu einer besseren Komprimierung, dauert aber länger. Ein niedrigeres Level führt zu einer geringeren Komprimierung, ist aber viel schneller.
Im Allgemeinen führen Optionen mit höherem Speicherverbrauch dazu, dass Node.js weniger Aufrufe an zlib machen muss, da es bei jeder write-Operation mehr Daten verarbeiten kann. Dies ist also ein weiterer Faktor, der die Geschwindigkeit beeinflusst, jedoch auf Kosten des Speicherverbrauchs.
Für Brotli-basierte Streams
Es gibt Entsprechungen zu den zlib-Optionen für Brotli-basierte Streams, obwohl diese Optionen andere Bereiche haben als die zlib-Optionen:
- Die
level-Option von zlib entspricht derBROTLI_PARAM_QUALITY-Option von Brotli. - Die
windowBits-Option von zlib entspricht derBROTLI_PARAM_LGWIN-Option von Brotli.
Weitere Informationen zu Brotli-spezifischen Optionen finden Sie unten.
Leeren
Das Aufrufen von .flush() auf einem Komprimierungsstream bewirkt, dass zlib so viel Ausgabe wie möglich zurückgibt. Dies kann auf Kosten einer geringeren Kompressionsqualität gehen, kann aber nützlich sein, wenn Daten so schnell wie möglich verfügbar sein müssen.
Im folgenden Beispiel wird flush() verwendet, um eine komprimierte partielle HTTP-Antwort an den Client zu schreiben:
import zlib from 'node:zlib'
import http from 'node:http'
import { pipeline } from 'node:stream'
http
.createServer((request, response) => {
// Der Einfachheit halber werden die Accept-Encoding-Prüfungen weggelassen.
response.writeHead(200, { 'content-encoding': 'gzip' })
const output = zlib.createGzip()
let i
pipeline(output, response, err => {
if (err) {
// Wenn ein Fehler auftritt, können wir nicht viel tun, da
// der Server bereits den Antwortcode 200 gesendet hat und
// bereits eine gewisse Datenmenge an den Client gesendet wurde.
// Das Beste, was wir tun können, ist, die Antwort sofort zu beenden
// und den Fehler zu protokollieren.
clearInterval(i)
response.end()
console.error('Es ist ein Fehler aufgetreten:', err)
}
})
i = setInterval(() => {
output.write(`Die aktuelle Zeit ist ${Date()}\n`, () => {
// Die Daten wurden an zlib übergeben, aber der Komprimierungsalgorithmus kann
// beschlossen haben, die Daten für eine effizientere Komprimierung zu puffern.
// Das Aufrufen von .flush() macht die Daten verfügbar, sobald der Client
// bereit ist, sie zu empfangen.
output.flush()
})
}, 1000)
})
.listen(1337)const zlib = require('node:zlib')
const http = require('node:http')
const { pipeline } = require('node:stream')
http
.createServer((request, response) => {
// Der Einfachheit halber werden die Accept-Encoding-Prüfungen weggelassen.
response.writeHead(200, { 'content-encoding': 'gzip' })
const output = zlib.createGzip()
let i
pipeline(output, response, err => {
if (err) {
// Wenn ein Fehler auftritt, können wir nicht viel tun, da
// der Server bereits den Antwortcode 200 gesendet hat und
// bereits eine gewisse Datenmenge an den Client gesendet wurde.
// Das Beste, was wir tun können, ist, die Antwort sofort zu beenden
// und den Fehler zu protokollieren.
clearInterval(i)
response.end()
console.error('Es ist ein Fehler aufgetreten:', err)
}
})
i = setInterval(() => {
output.write(`Die aktuelle Zeit ist ${Date()}\n`, () => {
// Die Daten wurden an zlib übergeben, aber der Komprimierungsalgorithmus kann
// beschlossen haben, die Daten für eine effizientere Komprimierung zu puffern.
// Das Aufrufen von .flush() macht die Daten verfügbar, sobald der Client
// bereit ist, sie zu empfangen.
output.flush()
})
}, 1000)
})
.listen(1337)Konstanten
Hinzugefügt in: v0.5.8
zlib-Konstanten
Alle in zlib.h definierten Konstanten sind auch in require('node:zlib').constants definiert. Im normalen Betriebsablauf ist es nicht notwendig, diese Konstanten zu verwenden. Sie sind dokumentiert, damit ihre Anwesenheit nicht überraschend ist. Dieser Abschnitt stammt fast direkt aus der zlib-Dokumentation.
Zuvor waren die Konstanten direkt über require('node:zlib') verfügbar, z. B. zlib.Z_NO_FLUSH. Der direkte Zugriff auf die Konstanten über das Modul ist derzeit noch möglich, aber veraltet.
Zulässige Flush-Werte.
zlib.constants.Z_NO_FLUSHzlib.constants.Z_PARTIAL_FLUSHzlib.constants.Z_SYNC_FLUSHzlib.constants.Z_FULL_FLUSHzlib.constants.Z_FINISHzlib.constants.Z_BLOCKzlib.constants.Z_TREES
Rückgabecodes für die Komprimierungs-/Dekomprimierungsfunktionen. Negative Werte sind Fehler, positive Werte werden für besondere, aber normale Ereignisse verwendet.
zlib.constants.Z_OKzlib.constants.Z_STREAM_ENDzlib.constants.Z_NEED_DICTzlib.constants.Z_ERRNOzlib.constants.Z_STREAM_ERRORzlib.constants.Z_DATA_ERRORzlib.constants.Z_MEM_ERRORzlib.constants.Z_BUF_ERRORzlib.constants.Z_VERSION_ERROR
Komprimierungsstufen.
zlib.constants.Z_NO_COMPRESSIONzlib.constants.Z_BEST_SPEEDzlib.constants.Z_BEST_COMPRESSIONzlib.constants.Z_DEFAULT_COMPRESSION
Komprimierungsstrategie.
zlib.constants.Z_FILTEREDzlib.constants.Z_HUFFMAN_ONLYzlib.constants.Z_RLEzlib.constants.Z_FIXEDzlib.constants.Z_DEFAULT_STRATEGY
Brotli-Konstanten
Hinzugefügt in: v11.7.0, v10.16.0
Es gibt mehrere Optionen und andere Konstanten, die für Brotli-basierte Streams verfügbar sind:
Flush-Operationen
Die folgenden Werte sind gültige Flush-Operationen für Brotli-basierte Streams:
zlib.constants.BROTLI_OPERATION_PROCESS(Standard für alle Operationen)zlib.constants.BROTLI_OPERATION_FLUSH(Standard beim Aufruf von.flush())zlib.constants.BROTLI_OPERATION_FINISH(Standard für den letzten Chunk)zlib.constants.BROTLI_OPERATION_EMIT_METADATA- Diese spezielle Operation kann in einem Node.js-Kontext schwierig zu verwenden sein, da die Streaming-Schicht es schwierig macht zu wissen, welche Daten in diesem Frame landen werden. Außerdem gibt es derzeit keine Möglichkeit, diese Daten über die Node.js-API zu nutzen.
Kompressor-Optionen
Es gibt mehrere Optionen, die bei Brotli-Encodern festgelegt werden können, die sich auf die Komprimierungseffizienz und -geschwindigkeit auswirken. Sowohl die Schlüssel als auch die Werte können als Eigenschaften des zlib.constants-Objekts aufgerufen werden.
Die wichtigsten Optionen sind:
BROTLI_PARAM_MODEBROTLI_MODE_GENERIC(Standard)BROTLI_MODE_TEXT, angepasst für UTF-8-TextBROTLI_MODE_FONT, angepasst für WOFF 2.0-Schriften
BROTLI_PARAM_QUALITY- Reicht von
BROTLI_MIN_QUALITYbisBROTLI_MAX_QUALITY, mit einem Standardwert vonBROTLI_DEFAULT_QUALITY.
- Reicht von
BROTLI_PARAM_SIZE_HINT- Ganzzahliger Wert, der die erwartete Eingabegröße darstellt; Standardwert ist
0für eine unbekannte Eingabegröße.
- Ganzzahliger Wert, der die erwartete Eingabegröße darstellt; Standardwert ist
Die folgenden Flags können für eine erweiterte Kontrolle über den Komprimierungsalgorithmus und die Speicherverbrauchsoptimierung festgelegt werden:
BROTLI_PARAM_LGWIN- Reicht von
BROTLI_MIN_WINDOW_BITSbisBROTLI_MAX_WINDOW_BITS, mit einem Standardwert vonBROTLI_DEFAULT_WINDOWoder bis zuBROTLI_LARGE_MAX_WINDOW_BITS, wenn das FlagBROTLI_PARAM_LARGE_WINDOWgesetzt ist.
- Reicht von
BROTLI_PARAM_LGBLOCK- Reicht von
BROTLI_MIN_INPUT_BLOCK_BITSbisBROTLI_MAX_INPUT_BLOCK_BITS.
- Reicht von
BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING- Boolesches Flag, das das Komprimierungsverhältnis zugunsten der Dekomprimierungsgeschwindigkeit verringert.
BROTLI_PARAM_LARGE_WINDOW- Boolesches Flag, das den "Large Window Brotli"-Modus aktiviert (nicht kompatibel mit dem im RFC 7932 standardisierten Brotli-Format).
BROTLI_PARAM_NPOSTFIX- Reicht von
0bisBROTLI_MAX_NPOSTFIX.
- Reicht von
BROTLI_PARAM_NDIRECT- Reicht von
0bis15 \<\< NPOSTFIXin Schritten von1 \<\< NPOSTFIX.
- Reicht von
Dekompressor-Optionen
Diese erweiterten Optionen stehen zur Steuerung der Dekomprimierung zur Verfügung:
BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION- Boolesches Flag, das sich auf interne Speicherzuordnungsmuster auswirkt.
BROTLI_DECODER_PARAM_LARGE_WINDOW- Boolesches Flag, das den "Large Window Brotli"-Modus aktiviert (nicht kompatibel mit dem im RFC 7932 standardisierten Brotli-Format).
Klasse: Options
[Verlauf]
| Version | Änderungen |
|---|---|
| v14.5.0, v12.19.0 | Die Option maxOutputLength wird jetzt unterstützt. |
| v9.4.0 | Die Option dictionary kann ein ArrayBuffer sein. |
| v8.0.0 | Die Option dictionary kann jetzt ein Uint8Array sein. |
| v5.11.0 | Die Option finishFlush wird jetzt unterstützt. |
| v0.11.1 | Hinzugefügt in: v0.11.1 |
Jede zlib-basierte Klasse akzeptiert ein options-Objekt. Es sind keine Optionen erforderlich.
Einige Optionen sind nur beim Komprimieren relevant und werden von den Dekompressionsklassen ignoriert.
flush<integer> Standard:zlib.constants.Z_NO_FLUSHfinishFlush<integer> Standard:zlib.constants.Z_FINISHchunkSize<integer> Standard:16 * 1024windowBits<integer>level<integer> (nur Komprimierung)memLevel<integer> (nur Komprimierung)strategy<integer> (nur Komprimierung)dictionary<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> (nur Deflate/Inflate, standardmäßig leeres Wörterbuch)info<boolean> (Wenntrue, gibt ein Objekt mitbufferundenginezurück.)maxOutputLength<integer> Begrenzt die Ausgabegröße bei Verwendung von Convenience-Methoden. Standard:buffer.kMaxLength
Weitere Informationen finden Sie in der Dokumentation zu deflateInit2 und inflateInit2.
Klasse: BrotliOptions
[Verlauf]
| Version | Änderungen |
|---|---|
| v14.5.0, v12.19.0 | Die Option maxOutputLength wird jetzt unterstützt. |
| v11.7.0 | Hinzugefügt in: v11.7.0 |
Jede auf Brotli basierende Klasse nimmt ein options-Objekt entgegen. Alle Optionen sind optional.
flush<integer> Standard:zlib.constants.BROTLI_OPERATION_PROCESSfinishFlush<integer> Standard:zlib.constants.BROTLI_OPERATION_FINISHchunkSize<integer> Standard:16 * 1024params<Object> Schlüssel-Wert-Objekt mit indizierten Brotli-Parametern.maxOutputLength<integer> Begrenzt die Ausgabegröße bei Verwendung von Komfortmethoden. Standard:buffer.kMaxLength
Zum Beispiel:
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,
},
})Klasse: zlib.BrotliCompress
Hinzugefügt in: v11.7.0, v10.16.0
Komprimiert Daten mit dem Brotli-Algorithmus.
Klasse: zlib.BrotliDecompress
Hinzugefügt in: v11.7.0, v10.16.0
Dekomprimiert Daten mit dem Brotli-Algorithmus.
Klasse: zlib.Deflate
Hinzugefügt in: v0.5.8
Komprimiert Daten mit Deflate.
Klasse: zlib.DeflateRaw
Hinzugefügt in: v0.5.8
Komprimiert Daten mit Deflate und hängt keinen zlib-Header an.
Klasse: zlib.Gunzip
[Verlauf]
| Version | Änderungen |
|---|---|
| v6.0.0 | Am Ende des Eingabestreams befindlicher nachgestellter Müll führt jetzt zu einem 'error'-Ereignis. |
| v5.9.0 | Mehrere verkettete gzip-Dateimember werden jetzt unterstützt. |
| v5.0.0 | Ein abgeschnittener Eingabestream führt jetzt zu einem 'error'-Ereignis. |
| v0.5.8 | Hinzugefügt in: v0.5.8 |
Dekomprimiert einen gzip-Stream.
Klasse: zlib.Gzip
Hinzugefügt in: v0.5.8
Komprimiert Daten mit gzip.
Klasse: zlib.Inflate
[Verlauf]
| Version | Änderungen |
|---|---|
| v5.0.0 | Ein abgeschnittener Eingabestream führt nun zu einem 'error'-Ereignis. |
| v0.5.8 | Hinzugefügt in: v0.5.8 |
Dekomprimiert einen Deflate-Stream.
Klasse: zlib.InflateRaw
[Verlauf]
| Version | Änderungen |
|---|---|
| v6.8.0 | Benutzerdefinierte Wörterbücher werden nun von InflateRaw unterstützt. |
| v5.0.0 | Ein abgeschnittener Eingabestream führt nun zu einem 'error'-Ereignis. |
| v0.5.8 | Hinzugefügt in: v0.5.8 |
Dekomprimiert einen rohen Deflate-Stream.
Klasse: zlib.Unzip
Hinzugefügt in: v0.5.8
Dekomprimiert entweder einen Gzip- oder Deflate-komprimierten Stream durch automatische Erkennung des Headers.
Klasse: zlib.ZlibBase
[Verlauf]
| Version | Änderungen |
|---|---|
| v11.7.0, v10.16.0 | Diese Klasse wurde von Zlib in ZlibBase umbenannt. |
| v0.5.8 | Hinzugefügt in: v0.5.8 |
Wird nicht vom Modul node:zlib exportiert. Es wird hier dokumentiert, weil es die Basisklasse der Kompressor-/Dekompressorklassen ist.
Diese Klasse erbt von stream.Transform, wodurch node:zlib-Objekte in Pipes und ähnlichen Stream-Operationen verwendet werden können.
zlib.bytesWritten
Hinzugefügt in: v10.0.0
Die zlib.bytesWritten-Eigenschaft gibt die Anzahl der Bytes an, die in die Engine geschrieben wurden, bevor die Bytes verarbeitet (komprimiert oder dekomprimiert, je nach abgeleiteter Klasse) werden.
zlib.crc32(data[, value])
Hinzugefügt in: v22.2.0, v20.15.0
data<string> | <Buffer> | <TypedArray> | <DataView> Wenndataein String ist, wird er als UTF-8 kodiert, bevor er für die Berechnung verwendet wird.value<integer> Ein optionaler Startwert. Er muss eine 32-Bit-Ganzzahl ohne Vorzeichen sein. Standard:0- Gibt zurück: <integer> Eine 32-Bit-Ganzzahl ohne Vorzeichen, die die Prüfsumme enthält.
Berechnet eine 32-Bit- Zyklische Redundanzprüfung-Prüfsumme von data. Wenn value angegeben ist, wird er als Startwert der Prüfsumme verwendet, andernfalls wird 0 als Startwert verwendet.
Der CRC-Algorithmus ist so konzipiert, dass er Prüfsummen berechnet und Fehler bei der Datenübertragung erkennt. Er ist nicht für die kryptografische Authentifizierung geeignet.
Um mit anderen APIs konsistent zu sein, wird data, falls es ein String ist, mit UTF-8 kodiert, bevor er für die Berechnung verwendet wird. Wenn Benutzer nur Node.js zum Berechnen und Vergleichen der Prüfsummen verwenden, funktioniert dies gut mit anderen APIs, die standardmäßig die UTF-8-Kodierung verwenden.
Einige JavaScript-Bibliotheken von Drittanbietern berechnen die Prüfsumme auf einem String basierend auf str.charCodeAt(), damit sie in Browsern ausgeführt werden kann. Wenn Benutzer die Prüfsumme abgleichen möchten, die mit dieser Art von Bibliothek im Browser berechnet wurde, ist es besser, dieselbe Bibliothek in Node.js zu verwenden, falls sie auch in Node.js ausgeführt wird. Wenn Benutzer zlib.crc32() verwenden müssen, um die Prüfsumme abzugleichen, die von einer solchen Bibliothek eines Drittanbieters erzeugt wurde:
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) // 4150509955const 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) // 4150509955zlib.close([callback])
Hinzugefügt in: v0.9.4
callback<Funktion>
Schließt das zugrunde liegende Handle.
zlib.flush([kind, ]callback)
Hinzugefügt in: v0.5.8
kindStandard:zlib.constants.Z_FULL_FLUSHfür zlib-basierte Streams,zlib.constants.BROTLI_OPERATION_FLUSHfür Brotli-basierte Streams.callback<Funktion>
Leert ausstehende Daten. Rufen Sie dies nicht leichtfertig auf, vorzeitiges Leeren beeinträchtigt die Wirksamkeit des Komprimierungsalgorithmus negativ.
Das Aufrufen dieser Funktion leert nur Daten aus dem internen zlib-Zustand und führt keine Art von Leeren auf der Stream-Ebene durch. Vielmehr verhält es sich wie ein normaler Aufruf von .write(), d. h. es wird hinter anderen ausstehenden Schreibvorgängen eingereiht und erzeugt nur dann eine Ausgabe, wenn Daten aus dem Stream gelesen werden.
zlib.params(level, strategy, callback)
Hinzugefügt in: v0.11.4
level<integer>strategy<integer>callback<Funktion>
Diese Funktion ist nur für zlib-basierte Streams verfügbar, d. h. nicht für Brotli.
Aktualisieren Sie dynamisch die Komprimierungsstufe und die Komprimierungsstrategie. Nur für den Deflate-Algorithmus anwendbar.
zlib.reset()
Hinzugefügt in: v0.7.0
Setzt den Kompressor/Dekompressor auf die Werkseinstellungen zurück. Nur anwendbar auf die Algorithmen inflate und deflate.
zlib.constants
Hinzugefügt in: v7.0.0
Stellt ein Objekt bereit, das Zlib-bezogene Konstanten auflistet.
zlib.createBrotliCompress([options])
Hinzugefügt in: v11.7.0, v10.16.0
options<brotli options>
Erstellt ein neues BrotliCompress-Objekt und gibt es zurück.
zlib.createBrotliDecompress([options])
Hinzugefügt in: v11.7.0, v10.16.0
options<Brotli-Optionen>
Erstellt ein neues BrotliDecompress-Objekt und gibt es zurück.
zlib.createDeflate([options])
Hinzugefügt in: v0.5.8
options<zlib-Optionen>
Erstellt ein neues Deflate-Objekt und gibt es zurück.
zlib.createDeflateRaw([options])
Hinzugefügt in: v0.5.8
options<zlib-Optionen>
Erstellt ein neues DeflateRaw-Objekt und gibt es zurück.
Ein Upgrade von zlib von 1.2.8 auf 1.2.11 änderte das Verhalten, wenn windowBits für rohe Deflate-Streams auf 8 gesetzt wurde. zlib würde windowBits automatisch auf 9 setzen, wenn es anfänglich auf 8 gesetzt war. Neuere Versionen von zlib werfen eine Ausnahme, daher hat Node.js das ursprüngliche Verhalten wiederhergestellt, bei dem ein Wert von 8 auf 9 erhöht wird, da die Übergabe von windowBits = 9 an zlib tatsächlich zu einem komprimierten Stream führt, der effektiv nur ein 8-Bit-Fenster verwendet.
zlib.createGunzip([options])
Hinzugefügt in: v0.5.8
options<zlib-Optionen>
Erstellt ein neues Gunzip-Objekt und gibt es zurück.
zlib.createGzip([options])
Hinzugefügt in: v0.5.8
options<zlib-Optionen>
Erstellt ein neues Gzip-Objekt und gibt es zurück. Siehe Beispiel.
zlib.createInflate([options])
Hinzugefügt in: v0.5.8
options<zlib-Optionen>
Erstellt ein neues Inflate-Objekt und gibt es zurück.
zlib.createInflateRaw([options])
Hinzugefügt in: v0.5.8
options<zlib-Optionen>
Erstellt ein neues InflateRaw-Objekt und gibt es zurück.
zlib.createUnzip([options])
Hinzugefügt in: v0.5.8
options<zlib-Optionen>
Erstellt ein neues Unzip-Objekt und gibt es zurück.
Komfortmethoden
Alle diese Methoden akzeptieren einen Buffer, TypedArray, DataView, ArrayBuffer oder eine Zeichenkette als erstes Argument, ein optionales zweites Argument zur Bereitstellung von Optionen für die zlib-Klassen und rufen den bereitgestellten Callback mit callback(error, result) auf.
Jede Methode hat ein *Sync-Gegenstück, das die gleichen Argumente akzeptiert, aber ohne Callback.
zlib.brotliCompress(buffer[, options], callback)
Hinzugefügt in: v11.7.0, v10.16.0
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<Brotli-Optionen>callback<Funktion>
zlib.brotliCompressSync(buffer[, options])
Hinzugefügt in: v11.7.0, v10.16.0
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<Brotli-Optionen>
Komprimiert einen Datenblock mit BrotliCompress.
zlib.brotliDecompress(buffer[, options], callback)
Hinzugefügt in: v11.7.0, v10.16.0
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<Brotli-Optionen>callback<Funktion>
zlib.brotliDecompressSync(buffer[, options])
Hinzugefügt in: v11.7.0, v10.16.0
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<Brotli-Optionen>
Dekomprimiert einen Datenblock mit BrotliDecompress.
zlib.deflate(buffer[, options], callback)
[Verlauf]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der Parameter buffer kann ein ArrayBuffer sein. |
| v8.0.0 | Der Parameter buffer kann ein beliebiges TypedArray oder DataView sein. |
| v8.0.0 | Der Parameter buffer kann jetzt ein Uint8Array sein. |
| v0.6.0 | Hinzugefügt in: v0.6.0 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib-Optionen>callback<Funktion>
zlib.deflateSync(buffer[, options])
[Verlauf]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der buffer-Parameter kann ein ArrayBuffer sein. |
| v8.0.0 | Der buffer-Parameter kann ein beliebiges TypedArray oder DataView sein. |
| v8.0.0 | Der buffer-Parameter kann jetzt ein Uint8Array sein. |
| v0.11.12 | Hinzugefügt in: v0.11.12 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib options>
Komprimiert einen Datenblock mit Deflate.
zlib.deflateRaw(buffer[, options], callback)
[Verlauf]
| Version | Änderungen |
|---|---|
| v8.0.0 | Der buffer-Parameter kann ein beliebiges TypedArray oder DataView sein. |
| v8.0.0 | Der buffer-Parameter kann jetzt ein Uint8Array sein. |
| v0.6.0 | Hinzugefügt in: v0.6.0 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib options>callback<Function>
zlib.deflateRawSync(buffer[, options])
[Verlauf]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der buffer-Parameter kann ein ArrayBuffer sein. |
| v8.0.0 | Der buffer-Parameter kann ein beliebiges TypedArray oder DataView sein. |
| v8.0.0 | Der buffer-Parameter kann jetzt ein Uint8Array sein. |
| v0.11.12 | Hinzugefügt in: v0.11.12 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib options>
Komprimiert einen Datenblock mit DeflateRaw.
zlib.gunzip(buffer[, options], callback)
[Historie]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der Parameter buffer kann ein ArrayBuffer sein. |
| v8.0.0 | Der Parameter buffer kann jedes TypedArray oder DataView sein. |
| v8.0.0 | Der Parameter buffer kann jetzt ein Uint8Array sein. |
| v0.6.0 | Hinzugefügt in: v0.6.0 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib-Optionen>callback<Funktion>
zlib.gunzipSync(buffer[, options])
[Historie]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der Parameter buffer kann ein ArrayBuffer sein. |
| v8.0.0 | Der Parameter buffer kann jedes TypedArray oder DataView sein. |
| v8.0.0 | Der Parameter buffer kann jetzt ein Uint8Array sein. |
| v0.11.12 | Hinzugefügt in: v0.11.12 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib-Optionen>
Dekomprimiert einen Datenblock mit Gunzip.
zlib.gzip(buffer[, options], callback)
[Historie]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der Parameter buffer kann ein ArrayBuffer sein. |
| v8.0.0 | Der Parameter buffer kann jedes TypedArray oder DataView sein. |
| v8.0.0 | Der Parameter buffer kann jetzt ein Uint8Array sein. |
| v0.6.0 | Hinzugefügt in: v0.6.0 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib-Optionen>callback<Funktion>
zlib.gzipSync(buffer[, options])
[Verlauf]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der buffer-Parameter kann ein ArrayBuffer sein. |
| v8.0.0 | Der buffer-Parameter kann ein beliebiges TypedArray oder DataView sein. |
| v8.0.0 | Der buffer-Parameter kann jetzt ein Uint8Array sein. |
| v0.11.12 | Hinzugefügt in: v0.11.12 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib-Optionen>
Komprimiert einen Datenblock mit Gzip.
zlib.inflate(buffer[, options], callback)
[Verlauf]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der buffer-Parameter kann ein ArrayBuffer sein. |
| v8.0.0 | Der buffer-Parameter kann ein beliebiges TypedArray oder DataView sein. |
| v8.0.0 | Der buffer-Parameter kann jetzt ein Uint8Array sein. |
| v0.6.0 | Hinzugefügt in: v0.6.0 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib-Optionen>callback<Funktion>
zlib.inflateSync(buffer[, options])
[Verlauf]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der buffer-Parameter kann ein ArrayBuffer sein. |
| v8.0.0 | Der buffer-Parameter kann ein beliebiges TypedArray oder DataView sein. |
| v8.0.0 | Der buffer-Parameter kann jetzt ein Uint8Array sein. |
| v0.11.12 | Hinzugefügt in: v0.11.12 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib-Optionen>
Dekomprimiert einen Datenblock mit Inflate.
zlib.inflateRaw(buffer[, options], callback)
[Verlauf]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der Parameter buffer kann ein ArrayBuffer sein. |
| v8.0.0 | Der Parameter buffer kann ein TypedArray oder DataView sein. |
| v8.0.0 | Der Parameter buffer kann nun ein Uint8Array sein. |
| v0.6.0 | Hinzugefügt in: v0.6.0 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib Optionen>callback<Funktion>
zlib.inflateRawSync(buffer[, options])
[Verlauf]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der Parameter buffer kann ein ArrayBuffer sein. |
| v8.0.0 | Der Parameter buffer kann ein TypedArray oder DataView sein. |
| v8.0.0 | Der Parameter buffer kann nun ein Uint8Array sein. |
| v0.11.12 | Hinzugefügt in: v0.11.12 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib Optionen>
Dekomprimiert einen Datenblock mit InflateRaw.
zlib.unzip(buffer[, options], callback)
[Verlauf]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der Parameter buffer kann ein ArrayBuffer sein. |
| v8.0.0 | Der Parameter buffer kann ein TypedArray oder DataView sein. |
| v8.0.0 | Der Parameter buffer kann nun ein Uint8Array sein. |
| v0.6.0 | Hinzugefügt in: v0.6.0 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib Optionen>callback<Funktion>
zlib.unzipSync(buffer[, options])
[Historie]
| Version | Änderungen |
|---|---|
| v9.4.0 | Der buffer-Parameter kann ein ArrayBuffer sein. |
| v8.0.0 | Der buffer-Parameter kann ein beliebiges TypedArray oder DataView sein. |
| v8.0.0 | Der buffer-Parameter kann jetzt ein Uint8Array sein. |
| v0.11.12 | Hinzugefügt in: v0.11.12 |
buffer<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <string>options<zlib Optionen>
Dekomprimiert einen Datenblock mit Unzip.