Node.js zlib: gzip, brotli va zstd bilan siqish

Qisqacha: node:zlib ma'lumotni siqadi va ochadi. Eng keng tarqalgani — gzip (HTTP va gz fayllar). Matn uchun brotli kichikroq, lekin eng yuqori darajada juda sekin. Node 24 da zstd ham bor — juda tez, lekin hujjatda hali "eksperimental". Takrorlanadigan matn (JSON, CSV, HTML) 5–10 barobar kichrayadi, tasodifiy yoki allaqachon siqilgan ma'lumot (rasm, .zip) — yo'q. Katta fayllar stream bilan siqiladi. Begona siqilgan ma'lumotni ochishda maxOutputLength bilan chegara qo'ying — aks holda "zip bomba" xotirani to'ldiradi. Siqish har doim ham foydali emas: kanon o'lchovi valyuta keshini siqmaslikka qaror qildi.

Bu darsda

• gzip, deflate, brotli va zstd ni sinab, hajm va tezlik farqini o'lchovlardan o'qiysiz.
• Siqish darajasi (level, quality) natijaga qanday ta'sir qilishini bilasiz.
• Siqilgan ma'lumotni sehrli baytlaridan taniysiz va noto'g'ri formatdagi xatoni tushunasiz.
• Accept-Encoding va Content-Encoding nima ekanini bilasiz.
• Zip bombadan himoyalanasiz va "siqish kerakmi?" degan savolga o'lchov bilan javob berasiz.

Oldin bilishingiz kerak: fs: uch API shakli, crypto 1 (Buffer va baytlar), HTTP sarlavhalari.

1. Nega bu kerak?

CBU javobi — 74 valyuta, 25 533 bayt JSON. Uning ichida "CcyNm_UZ", "Nominal", "Rate", "Date":"23.10.2026" kabi bo'laklar 74 marta takrorlanadi. Takrorlanadigan matn — siqish uchun ideal: "bu bo'lak avval bor edi, o'sha joydan ol" deb yozish ancha qisqa.

Siqish uch joyda pul va vaqtni tejaydi:

• Tarmoq — sayt HTML, JS va JSON'ni gzip/brotli bilan yuboradi; telefonda sekin internetda bu soniyalar degani. Siz buni Vite build natijasidagi "gzip" ustunida ko'rgansiz.
• Disk — loglar, zaxira nusxalar (backup.sql.gz), arxivlar.
• Xotira — ba'zi keshlar ma'lumotni siqib saqlaydi.

Lekin siqish bepul emas: protsessor vaqti sarflanadi, fayl inson ko'zi bilan o'qilmaydigan bo'ladi. Bu darsning asosiy savoli — qachon siqish kerak. Javobni kanon o'lchovi beradi.

O'xshatish: chamadon yig'ish. Kiyimni vakuum paketga solsangiz, chamadon yarim bo'sh qoladi. Lekin har safar biror narsa olish uchun paketni ochishingiz kerak. Ikki kunlik safar uchun vakuum paket — ortiqcha ovora.

2. Birinchi siqish

2.1 To'rt algoritm

zlib dagi har algoritmning sinxron (…Sync), callback va stream shakli bor (fs uch shakli kabi). Misollar uchun sinxron shakl qulay. CBU javobiga o'xshash 200 qatorli JSON yasaymiz:

import zlib from "node:zlib";

const qatorlar = Array.from({ length: 200 }, (_, i) => ({
  Ccy: "USD",
  Rate: (11900 + i / 100).toFixed(2),
  Date: "23.10.2026",
}));
const xom = Buffer.from(JSON.stringify(qatorlar));
console.log("xom", xom.length);
console.log("gzip", zlib.gzipSync(xom).length);
console.log("deflate", zlib.deflateSync(xom).length);
console.log("brotli", zlib.brotliCompressSync(xom).length);
console.log("zstd", zlib.zstdCompressSync(xom).length);

Konsolda:

xom 10401
gzip 568
deflate 556
brotli 309
zstd 279

10 KB dan yarim kilobaytga: 18–37 barobar. Ma'lumot juda takroriy bo'lgani uchun natija bunchalik yaxshi; haqiqiy CBU javobida farq kamroq (pastda).

zstd haqida bitta ogohlantirish. Node hujjatiga ko'ra (2026-10 holatiga), zstd funksiyalari v23.8.0 va v22.15.0 da qo'shilgan va Stability: 1 — Experimental (eksperimental) belgisida turibdi. Eksperimental — "ishlaydi, lekin API keyingi versiyalarda o'zgarishi mumkin" degani. Biz Node 24.21.0 da ishga tushirganimizda ogohlantirish chiqmadi. Kutubxona yoki uzoq yashaydigan fayl formati uchun hozircha gzip yoki brotli xavfsizroq tanlov.

2.2 Ochish va xatolar

Siqilganni ochish — teskari funksiya:

import zlib from "node:zlib";

const siqilgan = zlib.gzipSync("1 USD = 11 903.15 so'm");
console.log(zlib.gunzipSync(siqilgan).toString("utf8"));
try {
  zlib.gunzipSync(Buffer.from("bu gzip emas"));
} catch (xato) {
  console.log(xato.code, "—", xato.message);
}

Konsolda:

1 USD = 11 903.15 so'm
Z_DATA_ERROR — incorrect header check

"Sarlavha tekshiruvi noto'g'ri" — ma'lumot gzip formatida emas. Bu xato ko'pincha ikki marta ochishga urinishda chiqadi: masalan HTTP kutubxonasi javobni allaqachon ochgan, kod esa yana gunzip qiladi.

2.3 Sehrli baytlar

Har format o'ziga xos birinchi baytlar bilan boshlanadi — sehrli baytlar (magic bytes). Fayl kengaytmasiga emas, ularga qarab formatni bilish mumkin:

import zlib from "node:zlib";

const xom = Buffer.from("kurslar ".repeat(100));
const bosh = (b) => b.subarray(0, 4).toString("hex");
console.log("gzip", bosh(zlib.gzipSync(xom)));
console.log("zstd", bosh(zlib.zstdCompressSync(xom)));

Konsolda:

gzip 1f8b0800
zstd 28b52ffd

gzip doim 1f 8b bilan, zstd — 28 b5 2f fd bilan boshlanadi. Brotli'ning sehrli baytlari yo'q — u faqat HTTP sarlavhasi yoki fayl kengaytmasidan (.br) taniladi.

Tekshirib ko'ring: Foydalanuvchi kurslar.csv.gz nomli fayl yubordi, lekin gunzipSync incorrect header check berdi. Birinchi nima qilasiz?

3. Siqish darajasi

3.1 Tezlik va hajm savdosi

Har algoritmda "qanchalik qattiq harakat qilay" sozlamasi bor. gzip/deflate uchun level (1 — tez, 9 — kichik, sukut 6), brotli uchun quality (0–11, sukut 11):

import zlib from "node:zlib";

const qatorlar = Array.from({ length: 200 }, (_, i) => ({
  Ccy: "USD", Rate: (11900 + i / 100).toFixed(2), Date: "23.10.2026",
}));
const xom = Buffer.from(JSON.stringify(qatorlar));
console.log(zlib.gzipSync(xom, { level: 1 }).length);
console.log(zlib.gzipSync(xom, { level: 9 }).length);
const q4 = { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 4 } };
console.log(zlib.brotliCompressSync(xom, q4).length);

Konsolda:

639
568
277

gzip level 1 — 639 bayt, level 9 — 568. Farq 11 %. Brotli quality 4 — 277, sukut (11) esa yuqoridagi blokda 309 edi. Kutilmagan natija: bu kichik va juda takroriy ma'lumotda past daraja kichikroq chiqdi. Darajalar va'da emas, taxminiy yo'nalish — har ma'lumotda o'lchash kerak. Haqiqiy CBU javobida (pastda) manzara boshqacha.

3.2 Kanon o'lchovi: CBU javobi

Kanon haqiqiy CBU javobini (25 533 bayt) har usulda 200–1000 marta siqib va ochib, o'rtacha vaqtni o'lchadi (Node 24.21.0, i5-12500H, Windows 11):

xom: 25533 bayt; JSON.parse 88 µs
gzip                   4722 bayt (18.5 %), siqish 738 µs, ochish 70 µs
brotli (q11 sukut)     3835 bayt (15.0 %), siqish 42081 µs, ochish 134 µs
brotli q4              5286 bayt (20.7 %), siqish 309 µs, ochish 86 µs
zstd                   5464 bayt (21.4 %), siqish 87 µs, ochish 92 µs
zstd mavjud: true

µs — mikrosekund, millisekundning mingdan biri. Hajmlarni rasmda ko'ring:

Uchta xulosa:

1. Hamma usul 4–6 barobar kichraytirdi — matnli JSON uchun odatiy natija.
2. Brotli sukut (q11) eng kichik, lekin siqishi 42 ms — gzip'dan 57 barobar sekin. Statik fayl uchun bu arzimas: bir marta build vaqtida siqiladi, million marta yuboriladi. Har so'rovda jonli siqish uchun esa juda qimmat — serverlar jonli javobda brotli'ni 4–6 darajada ishlatadi.
3. zstd eng tez siqadi (87 µs), hajmi biroz kattaroq. Tezlik kerak bo'lgan joyda (loglar, ma'lumotlar bazasi, real vaqt) — yaxshi tanlov.

Ochish hamma usulda tez (70–134 µs). Siqish sekin bo'lishi mumkin, ochish — deyarli doim tez.

Tekshirib ko'ring: Saytingiz app.js (500 KB) ni har so'rovda brotli q11 bilan siqib yuboradi. Nima noto'g'ri va qanday tuzatiladi?

4. Nima siqiladi, nima siqilmaydi

Siqish takrorni topadi. Takror yo'q bo'lsa — siqiladigan narsa yo'q:

import { randomBytes } from "node:crypto";
import zlib from "node:zlib";

const tasodif = randomBytes(1000);
console.log(zlib.gzipSync(tasodif).length);
const birMarta = zlib.gzipSync(Buffer.from("USD ".repeat(500)));
const ikkiMarta = zlib.gzipSync(birMarta);
console.log(ikkiMarta.length > birMarta.length);

Konsolda:

1023
true

1000 tasodifiy bayt gzip'dan keyin 1023 bayt bo'ldi — kattalashdi (sarlavha va "siqilmagan blok" belgilari qo'shildi). Ikki marta siqish ham foyda bermaydi. Shu sababli:

Oxirgi qatordan muhim qoida: kerak bo'lsa avval siqing, keyin shifrlang. Teskarisida siqish ishlamaydi.

5. Stream bilan siqish

Katta faylni (yuzlab MB) readFile + gzipSync bilan siqsangiz, butun fayl va natija xotirada turadi va siqish paytida event loop to'xtaydi. To'g'ri yo'l — stream (oqim): fayl bo'lak-bo'lak o'qiladi, siqiladi va yoziladi. Stream'larni Stream nima darsidan boshlab chuqur o'rganamiz; hozir faqat ko'rinishi:

import { createReadStream, createWriteStream } from "node:fs";
import { readFile, stat, writeFile } from "node:fs/promises";
import { pipeline } from "node:stream/promises";
import { createGunzip, createGzip } from "node:zlib";

const qator = "2026-10-23,USD,11903.15\n";
const csv = "sana,kod,kurs\n" + qator.repeat(5000);
await writeFile("tarix.csv", csv);
await pipeline(
  createReadStream("tarix.csv"),
  createGzip(),
  createWriteStream("tarix.csv.gz"),
);
console.log((await stat("tarix.csv")).size);
console.log((await stat("tarix.csv.gz")).size < 1000);

Konsolda:

120014
true

120 KB CSV bir kilobaytdan kichik faylga aylandi (har qator bir xil — takrorning eng yaxshi holati). pipeline uchta bo'g'inni ulaydi: o'quvchi → siquvchi → yozuvchi. Xato bo'lsa — hammasini to'g'ri yopadi. Ochish — xuddi shunday, createGunzip() bilan.

Bu bilim valyuta da katta faylni stream bilan qayta ishlash darsida kerak bo'ladi: valyuta tarix … -o eur.csv.gz --gzip. Kanon u yerda 895 baytlik CSV'ni 317 baytga siqdi.

6. HTTP'da siqish: Accept-Encoding

Brauzer so'rovda qaysi formatlarni tushunishini aytadi, server javobda qaysini ishlatganini aytadi (HTTP sarlavhalari):

So'rov:  Accept-Encoding: gzip, deflate, br, zstd
Javob:   Content-Encoding: br
         Vary: Accept-Encoding

Vary: Accept-Encoding — keshlarga "bu manzilning javobi Accept-Encoding ga qarab har xil" degan ogohlantirish. Usiz CDN gzip'ni tushunmaydigan mijozga ham siqilgan javob berib yuborishi mumkin.

Server tanlovini toza funksiya bilan yozish mumkin — bu blok saytda ham ishlaydi:

const AFZAL = ["zstd", "br", "gzip"];

function kodlashniTanla(acceptEncoding) {
  const bor = new Set(
    (acceptEncoding ?? "")
      .split(",")
      .map((q) => q.trim().split(";")[0].toLowerCase())
      .filter(Boolean),
  );
  return AFZAL.find((k) => bor.has(k)) ?? "identity";
}

console.log(kodlashniTanla("gzip, deflate, br, zstd"));
console.log(kodlashniTanla("gzip, deflate, br"));
console.log(kodlashniTanla("gzip;q=1.0, identity"));
console.log(kodlashniTanla(undefined));

Konsolda:

zstd
br
gzip
identity

identity — "siqilmagan". Haqiqiy serverda q= (afzallik og'irligi) ham hisobga olinadi; bu soddalashtirilgan versiya. Odatda bu ishni o'zingiz qilmaysiz: nginx, CDN yoki freymvork (Express'da compression middleware) bajaradi. Serverni keyingi qismda yozamiz.

7. Hujumchi nigohi: zip bomba

10 MB nollar gzip bilan bir necha kilobaytga aylanadi. Teskari tomonga o'ylang: hujumchi 10 KB siqilgan fayl yuboradi, server uni ochadi — va xotirada 10 MB (yoki 10 GB) paydo bo'ladi. Bu zip bomba (decompression bomb). Fayl yuklash, siqilgan so'rov tanasi (Content-Encoding: gzip bilan POST) — hammasi bu hujumga ochiq.

Himoya — ochilgan hajmga chegara:

import zlib from "node:zlib";

const bomba = zlib.gzipSync(Buffer.alloc(10_000_000));
console.log(bomba.length);
try {
  zlib.gunzipSync(bomba, { maxOutputLength: 1_000_000 });
} catch (xato) {
  console.log(xato.code);
  console.log(xato.message);
}

Konsolda:

9750
ERR_BUFFER_TOO_LARGE
Cannot create a Buffer larger than 1000000 bytes

9 750 baytlik fayl ichida 10 MB yashiringan — 1 000 barobardan ko'p. maxOutputLength bilan ochish 1 MB da to'xtadi: "1 000 000 baytdan katta Buffer yaratib bo'lmaydi". Stream bilan ochishda esa o'qilgan baytlarni o'zingiz sanab, chegaradan oshganda oqimni to'xtatasiz.

8. CLI qadami o'rniga: nega valyuta keshi siqilmaydi

Kanon valyuta keshini siqishni o'lchab ko'rdi va rad etdi. Hisob:

20 KB — bugungi diskda hech narsa. Lekin siqilgan keshda xato chiqsa, siz uni cat bilan ochib ko'ra olmaysiz. Kod ham murakkablashadi: atomik yozish, buzilgan keshni aniqlash — hammasi ikki qadamga ko'payadi.

Siqish o'rni boshqa joyda: foydalanuvchi so'ragan katta eksport — valyuta tarix yuzlab kunlik CSV chiqarganda --gzip bayrog'i (katta fayl darsi). U yerda fayl katta, foydalanuvchi uni yuboradi yoki saqlaydi, siqish o'zini oqlaydi.

Bu dars kodi valyuta ga kirmaydi. Saboq kodning o'zidan muhimroq: optimallashtirishdan oldin o'lchang. "Siqish yaxshi narsa" degan umumiy fikr bilan emas, aniq raqam bilan qaror qiling.

9. Ko'p uchraydigan xatolar

10. Mashqlar

1-mashq (oson): bo'sh joylar

• gzip faylining birinchi ikki bayti (hex):
• Brotli sukut sifat darajasi:
• Node 24 da bor, lekin hali eksperimental tez algoritm:
• Siqilmagan javobning Content-Encoding nomi:
• Zip bombaga qarshi gunzipSync opsiyasi:

2-mashq (o'rta): formatni aniqlash

formatniAniqla(buf) funksiyasini yozing: birinchi baytlarga qarab "gzip", "zstd", "zlib" (deflate 78 bilan boshlanadi) yoki "noma'lum" qaytarsin. Keyin ochAvtomatik(buf) — aniqlangan format bo'yicha ochsin. Brotli'ni aniqlab bo'lmasligini eslang.

import zlib from "node:zlib";

function formatniAniqla(buf) {
  if (buf[0] === 0x1f && buf[1] === 0x8b) return "gzip";
  const bosh = buf.subarray(0, 4).toString("hex");
  if (bosh === "28b52ffd") return "zstd";
  if (buf[0] === 0x78) return "zlib";
  return "noma'lum";
}

const OCHUVCHI = {
  gzip: zlib.gunzipSync,
  zstd: zlib.zstdDecompressSync,
  zlib: zlib.inflateSync,
};

function ochAvtomatik(buf) {
  const f = formatniAniqla(buf);
  return f in OCHUVCHI ? OCHUVCHI[f](buf).toString() : `(${f})`;
}

const matn = "USD 11903.15";
console.log(ochAvtomatik(zlib.gzipSync(matn)));
console.log(ochAvtomatik(zlib.zstdCompressSync(matn)));
console.log(ochAvtomatik(zlib.deflateSync(matn)));
console.log(ochAvtomatik(zlib.brotliCompressSync(matn)));

USD 11903.15
USD 11903.15
USD 11903.15
(noma'lum)

3-mashq (qiyin): siqish qarori

siqishKerakmi(xom, minTejash) funksiyasini yozing: gzip bilan siqib, tejalgan baytlar minTejash dan ko'p va siqilgan hajm xomning 80 % idan kichik bo'lsa — { siq: true, hajm }, aks holda { siq: false, sabab }. Uch holatni sinang: kichik JSON (200 bayt), katta takroriy CSV (50 KB), tasodifiy 50 KB. minTejash — 10 000 bayt.

import { randomBytes } from "node:crypto";
import zlib from "node:zlib";

function siqishKerakmi(xom, minTejash) {
  const hajm = zlib.gzipSync(xom).length;
  if (hajm >= xom.length * 0.8) {
    return { siq: false, sabab: "siqilmaydi" };
  }
  if (xom.length - hajm < minTejash) {
    return { siq: false, sabab: "tejash kam" };
  }
  return { siq: true, hajm };
}

const kichik = Buffer.from(JSON.stringify({ kod: "USD" }).repeat(14));
const csv = Buffer.from("2026-10-23,USD,11903.15\n".repeat(2100));
console.log(kichik.length, siqishKerakmi(kichik, 10_000));
console.log(csv.length, siqishKerakmi(csv, 10_000).siq);
console.log(siqishKerakmi(randomBytes(50_000), 10_000));

182 { siq: false, sabab: 'tejash kam' }
50400 true
{ siq: false, sabab: 'siqilmaydi' }

4-mashq: amaliy tajriba

valyuta keshidagi haqiqiy faylni (valyuta joylar ko'rsatgan papkadan) olib, gzip, brotli (q4 va q11) va zstd bilan siqing va hajm/vaqtni chiqaring. Natijangizni kanon jadvali bilan solishtiring. Kodni valyuta ga qo'shmang.

11. Real ishda

• Veb-serverlar va CDN — nginx (gzip on, brotli), Cloudflare, Vercel avtomatik siqadi; Vite/Next build statik fayllarni oldindan siqishi mumkin.
• Zaxiralar va loglar — pg_dump | gzip, logrotate .gz arxivlari, Docker image qatlamlari (gzip yoki zstd).
• API — katta JSON javoblar compression middleware bilan; mobil ilovalar uchun trafik tejash.
• Intervyu savollari: "gzip va brotli farqi?", "Nega rasmlarni gzip qilmaymiz?", "Zip bomba nima?".

Xulosa

• zlib — gzip, deflate, brotli va zstd (Node 24 da bor, hali eksperimental); har birining Sync, callback va stream shakli bor.
• Matnli JSON 4–6 barobar kichrayadi; tasodifiy va allaqachon siqilgan ma'lumot — yo'q (1000 → 1023 bayt).
• Kanon: brotli q11 eng kichik (3 835), lekin 42 ms; gzip 0.7 ms; zstd 0.09 ms — statik uchun oldindan brotli, jonli uchun tez daraja.
• Katta fayl — stream (pipeline + createGzip); begona ma'lumot — maxOutputLength (zip bomba).
• valyuta keshi siqilmaydi: 20 KB tejash murakkablikka arzimaydi — optimallashtirishdan oldin o'lchang.

Keyingi dars: readline va terminal — valyuta interaktiv bo'ladi: savol-javob, Ctrl+C va terminal o'lchami.

Manbalar

• Node.js 24 hujjati — Zlib (gzip, brotli, zstd — "added: v23.8.0, v22.15.0", Stability 1 Experimental; maxOutputLength, stream'lar)
• MDN — Accept-Encoding, Content-Encoding
• RFC 1952 — gzip; RFC 7932 — Brotli; RFC 8878 — Zstandard
• OWASP — File Upload Cheat Sheet (decompression bomb)