Node.js Buffer: baytlar, UTF-8, base64, hex va binar ma'lumot

Qisqacha: Buffer — Node'dagi baytlar massivi (aslida Uint8Array ning kengaytmasi). Fayl, tarmoq va siqilgan ma'lumot baytlarda keladi; matn bo'lishi uchun ular kodlash (encoding) bilan o'qiladi — odatda UTF-8. Bir belgi bir bayt emas: "so'm" — 4 bayt, ʻ (U+02BB) bilan — 5 bayt. Ko'p baytli belgi ikki bo'lak orasida bo'linsa, har bo'lakni alohida toString() qilish matnni buzadi — StringDecoder yoki Buffer.concat kerak.

Bu darsda

• Buffer.from, Buffer.alloc va allocUnsafe bilan bufer yaratasiz va farqini bilasiz.
• utf8, base64, base64url, hex, latin1 kodlashlari orasida o'girasiz.
• Satr uzunligi (length) va bayt hajmi (byteLength) nega farq qilishini tushuntirasiz.
• subarray umumiy xotira ekanini, Buffer.concat va StringDecoder qachon kerakligini bilasiz.
• Sonlarni baytlarga yozib-o'qiysiz (writeUInt32BE, readDoubleLE).

Oldin bilishingiz kerak: Matn kodlash: ASCII, Unicode va UTF-8, Typed arrays va binar ma'lumot, Unicode va emoji, crypto 1: hash va HMAC.

1. Nega bu kerak?

Kompyuter matnni bilmaydi — u faqat baytlarni biladi: 0 dan 255 gacha sonlar. Fayl diskda — baytlar. Tarmoq orqali kelgan javob — baytlar. Siqilgan .gz fayl — baytlar. "salom" degan matn — ular faqat siz ma'lum bir qoida (kodlash) bilan o'qiganingizdagina.

Oldingi darslarda baytlarni ko'p uchratdingiz, lekin ichiga qaramadik:

• child_process da encoding: "utf8" berilmasa, execFileSync satr emas, <Buffer 34 32 0a> qaytaradi.
• net da soketdan kelgan chunk ni String(chunk) qildik.
• valyuta testida: chiqish.on("data", (b: Buffer) => (matn += b.toString())).

Bu darsda o'sha Buffer ning ichini ochamiz. Sabab amaliy: o'zbekcha matn bilan ishlaganda baytlar va belgilar soni farq qiladi va buni bilmagan dastur o'zbek harflarini buzadi.

O'xshatish: Buffer — bir qator kataklar, har katakda 0–255 oralig'idagi bitta son. Kodlash — shu sonlarni harflarga aylantiradigan lug'at. Bir xil kataklar UTF-8 lug'ati bilan "soʻm", latin1 lug'ati bilan "soÊ»m" bo'ladi.

2. Buffer yaratish

2.1 Matndan va sonlardan

const fromText = Buffer.from("salom");
const fromBytes = Buffer.from([115, 97, 108, 111, 109]);

console.log(fromText); // <Buffer 73 61 6c 6f 6d>
console.log(fromBytes.toString()); // salom
console.log(fromText.length); // 5
console.log(fromText[0]); // 115

Node bufer ichini o'n oltilik (hex) sonlarda ko'rsatadi: 73 = 115 = "s". Buffer.from(satr) sukut bo'yicha UTF-8 bilan kodlaydi, toString() sukut bo'yicha UTF-8 bilan o'qiydi. buf[0] — bitta bayt, oddiy son.

Buffer — Uint8Array ning bolasi (Typed arrays). Shuning uchun massiv metodlarining ko'pi ishlaydi: indeks, length, for…of. Kanon tajribasi: Buffer instanceof Uint8Array — true (t29-buffer.txt).

2.2 alloc va allocUnsafe

Bo'sh joy kerak bo'lsa:

const safe = Buffer.alloc(4);
const filled = Buffer.alloc(5, "ab");
console.log(safe); // <Buffer 00 00 00 00>
console.log(filled.toString()); // ababa

allocUnsafe xotirani tozalamaydi: ichida oldin boshqa ma'lumot (parol, token, boshqa foydalanuvchining so'rovi) turgan bo'lishi mumkin. Agar uni to'liq to'ldirmasdan tashqariga yuborsangiz — o'sha qoldiq ham ketadi. Shuning uchun qoida: alloc ishlating. allocUnsafe faqat keyingi qatorda butun buferni o'zingiz to'ldirasiz degan aniq holatda.

Eski kodda new Buffer(10) ni ko'rasiz — bu eskirgan (deprecated) va xavfli edi: aynan shu "tozalanmagan xotira" muammosi sabab alloc/allocUnsafe ga bo'lingan.

3. Kodlashlar

3.1 Beshta asosiy kodlash

Bir xil baytlarni turli ko'rinishda yozish mumkin:

const buf = Buffer.from("salom");
console.log(buf.toString("hex")); // 73616c6f6d
console.log(buf.toString("base64")); // c2Fsb20=
console.log(buf.toString("base64url")); // c2Fsb20
console.log(Buffer.from("c2Fsb20=", "base64").toString()); // salom

base64 — binar ma'lumotni faqat "xavfsiz" harflar bilan yozish usuli. Hajmi ~33 % ga oshadi (3 bayt → 4 belgi), lekin JSON yoki URL ichida buzilmaydi. base64url farqi: + va / URL'da maxsus ma'noga ega, shuning uchun ular - va _ ga almashadi, oxiridagi = tashlanadi. Kanon misoli: "??>>" — base64 da Pz8+Pg==, base64url da Pz8-Pg.

hex ni crypto 1 darsida ko'rgansiz: valyuta ning kesh kaliti — createHash("sha256").update(url).digest("hex").slice(0, 16). digest() aslida Buffer qaytaradi, "hex" uni o'qiladigan satrga aylantiradi.

3.2 Noto'g'ri kodlash — buzilgan matn

Kodlash o'qishda ham, yozishda ham bir xil bo'lishi shart. Aks holda — mojibake (buzilgan belgilar):

const bytes = Buffer.from("so\u02BBm"); // UTF-8 bilan yozildi
console.log(bytes.toString("utf8")); // soʻm
console.log(bytes.toString("latin1")); // soʻm

Bir xil baytlar, ikki xil lug'at. UTF-8 da ca bb — bitta belgi (U+02BB), latin1 da esa ikkita: Ê va ». Sayt yoki Excel faylida "ü", "Ê»" kabi belgilarni ko'rsangiz — bu aynan shu: UTF-8 baytlar boshqa kodlash bilan o'qilgan. Kanon tajribasida: Buffer.from("soʻm", "latin1") → so�m — bu safar teskari yo'nalish (latin1 ga sig'maydigan belgi buzildi).

Tekshirib ko'ring: 30 baytli rasmni base64 ga o'girsangiz, natija necha belgi bo'ladi?

4. length va byteLength: o'zbek harflari

4.1 Uch xil "uzunlik"

Unicode va emoji darsida satr length i belgilarni emas, UTF-16 birliklarini sanashini ko'rgansiz. Endi uchinchi o'lchov — UTF-8 baytlar:

const text = "Osh — 35 000 so'm 🍚";
console.log(text.length); // 20
console.log([...text].length); // 19
console.log(Buffer.byteLength(text)); // 24

• [...text].length — 19: haqiqiy belgilar soni.
• text.length — 20: emoji JavaScript ichida 2 birlik.
• Buffer.byteLength — 24: UTF-8 da tire — 3 bayt, emoji 4 bayt, qolganlari 1 baytdan.

Qaysi biri muhim? Baytlar — diskda, tarmoqda va bazada joy aynan bayt bilan o'lchanadi. Content-Length sarlavhasi, "SMS 160 belgi", "maydon 255 bayt" — hammasi bayt.

4.2 Tutuq belgisi: ' yoki ʻ

O'zbek lotin alifbosida o' va g' uchun ikki xil belgi ishlatiladi. Kanon tajribasi (t29-buffer.txt, Node 24.21.0):

"Oʻzbekiston soʻmi — so'm": 24 belgi (UTF-16), 28 bayt (UTF-8); ʻ (U+02BB) = cabb, ' = 27

• Oddiy apostrof ' (U+0027) — ASCII, 1 bayt (27).
• O'zbek tutuq belgisi ʻ (U+02BB, "modifier letter turned comma") — 2 bayt (ca bb).

const plain = "O'zbekiston";
const turned = "O\u02BBzbekiston";
console.log(plain.length, Buffer.byteLength(plain)); // 11 11
console.log(turned.length, Buffer.byteLength(turned)); // 11 12

Ko'zga bir xil, belgilar soni bir xil, lekin baytlar har xil. Amaliy natijalari: 255 baytli maydonga sig'ish hisobi, "o'" ni qidirganda ʻ li matn topilmaydi (boshqa belgi!), fayl nomlarida turli tizimlar turlicha ko'rsatadi. IlmHamroh kursi matnida oddiy ' ishlatiladi. Tashqi manbalar esa uchinchi belgini ham ishlatadi — valyuta ning CBU ma'lumotida aynan shunday (pastdagi 4-mashqda biz topgan natija).

Brauzerda Buffer yo'q, lekin xuddi shu hisobni TextEncoder beradi — bu blok saytda ham ishlaydi:

const encoder = new TextEncoder();
console.log(encoder.encode("so'm").length);
console.log(encoder.encode("so\u02BBm").length);
console.log(encoder.encode("so\u02BBm"));

Konsolda:

4
5
Uint8Array(5) [ 115, 111, 202, 187, 109 ]

TextEncoder doim UTF-8 bilan Uint8Array qaytaradi. Brauzer konsoli massivni boshqacha ko'rsatishi mumkin — ma'nosi bir xil.

Tekshirib ko'ring: Bazadagi maydon "100 baytgacha". Foydalanuvchi 60 belgili o'zbekcha nom yozdi, ichida 6 ta ʻ bor, qolgani lotin harflari. Sig'adimi?

5. Bo'laklar: subarray, concat va bo'lingan belgi

5.1 subarray — nusxa emas

const original = Buffer.from([1, 2, 3, 4]);
const part = original.subarray(1, 3);
part[0] = 99;
console.log(original); // <Buffer 01 63 03 04>

subarray yangi bufer yaratmaydi — o'sha xotiraning bir qismiga "deraza" ochadi. part ni o'zgartirdik — original ham o'zgardi (63 = 99). Kanon tajribasida ham aynan shu natija. Bu tez (nusxa yo'q), lekin kutilmagan o'zgarish manbai.

Diqqat: Buffer da slice() ham umumiy xotira beradi (u eskirgan, subarray bilan bir xil), Uint8Array dagi slice() esa nusxa oladi. Bir xil nom, ikki xil xulq — shuning uchun Node hujjati subarray ni tavsiya qiladi, nusxa kerak bo'lsa — Buffer.from(buf).

5.2 Buffer.concat — bo'laklarni birlashtirish

Oqimdan bo'laklar kelsa, ularni yig'ib, bitta buferga birlashtirish mumkin:

const parts = [Buffer.from("osh "), Buffer.from("manti")];
const all = Buffer.concat(parts);
console.log(all.toString(), all.length); // osh manti 9

5.3 Bo'lingan belgi: eng ko'p uchraydigan xato

Endi muhim tuzoq. "soʻm" ning 5 bayti tarmoqdan ikki bo'lakda keldi va bo'lak chegarasi aynan ʻ ning o'rtasiga tushdi: 73 6f ca | bb 6d. Har bo'lakni alohida matnga aylantirsak:

import { StringDecoder } from "node:string_decoder";

const chunks = [
  Buffer.from([0x73, 0x6f, 0xca]),
  Buffer.from([0xbb, 0x6d]),
];

// ❌ har bo'lakni alohida
console.log(chunks.map((c) => c.toString()).join(""));
// ✅ avval baytlarni birlashtirish
console.log(Buffer.concat(chunks).toString());
// ✅ StringDecoder — chala belgini keyingi bo'lakkacha saqlaydi
const decoder = new StringDecoder("utf8");
const parts = chunks.map((c) => decoder.write(c));
console.log(parts.join("") + decoder.end());

Konsolda:

so��m
soʻm
soʻm

Birinchi usulda ca yolg'iz qoldi — UTF-8 da u "davomi bor" degan bayt, davomisiz u yaroqsiz va � (almashtirish belgisi) ga aylanadi. bb ham yolg'iz — yana �. Ikkita buzilgan belgi.

Diagrammada ikki yo'lni solishtiring: yuqorida har bo'lak alohida o'qiladi, pastda StringDecoder chala baytni keyingi bo'lakkacha ushlab turadi.

flowchart LR
  subgraph A["har bo'lak alohida toString"]
    A1["73 6f ca"] --> A2["so�"]
    A3["bb 6d"] --> A4["�m"]
  end
  subgraph B["StringDecoder"]
    B1["73 6f ca"] --> B2["so<br/>ca — kutadi"]
    B3["bb 6d"] --> B4["ʻm<br/>ca bb birlashdi"]
  end

Ikki to'g'ri yo'l:

• Buffer.concat — avval hamma baytni yig'ib, keyin bir marta o'qish. Oddiy, lekin butun ma'lumot xotirada.
• StringDecoder — har bo'lakdan to'liq belgilarni chiqaradi, chala qolganini keyingi bo'lakkacha saqlaydi. Oqimlar uchun shu kerak. Brauzerdagi ekvivalenti: new TextDecoder().decode(chunk, { stream: true }).

Lotin harflari bilan sinaganda bu xato ko'rinmaydi — ular 1 bayt, hech qachon bo'linmaydi. O'zbekcha ʻ, kirill, emoji paydo bo'lganda — "ba'zan" buzilgan harflar chiqadi. Bunday "ba'zan"lik xatolarni topish qiyin. Stream'lar bilan ishlaganda Node buni setEncoding("utf8") orqali hal qiladi — ichida aynan StringDecoder (Stream nima). readline ham ichida shuni ishlatadi — shuning uchun u "lag'mon" ni to'g'ri yig'di.

6. Sonlar baytlarda

Binar formatlar (rasm, arxiv, tarmoq protokoli) sonlarni matn emas, baytlar sifatida saqlaydi. Buffer'da buning uchun write… / read… metodlari bor:

const header = Buffer.alloc(4);
header.writeUInt32BE(297); // 297 — 4 baytli butun son
console.log(header); // <Buffer 00 00 01 29>
console.log(header.readUInt32BE()); // 297

const rate = Buffer.alloc(8);
rate.writeDoubleLE(11903.15); // 8 baytli kasr son
console.log(rate.toString("hex")); // 33333333933fc740
console.log(rate.readDoubleLE()); // 11903.15

Nomlarda uchta ma'lumot bor. Birinchisi — son turi: UInt32 ishorasiz 32 bitli butun son (4 bayt). Ikkinchisi — Double: 64 bitli kasr son (8 bayt, JS'dagi number ning o'zi). Uchinchisi — BE/LE, ya'ni bayt tartibi (endianness). Big Endian — katta bayt oldin (00 00 01 29, odam o'qiydigan tartib, tarmoq protokollari). Little Endian — kichik bayt oldin (ko'p protsessorlar shunday saqlaydi).

net darsidagi uzunlik prefiksli protokolni eslang: haqiqiy protokollarda uzunlik "5:" matni emas, aynan shunday 4 baytli UInt32BE bo'ladi. Kanon misoli — writeDoubleLE(11903.15) → 33333333933fc740, dollar kursi 8 bayt.

7. CLI qadami: holat yo'q — Buffer ichkarida

valyuta Buffer'ni to'g'ridan yaratmaydi — unga binar format kerak emas: CBU JSON matn beradi, kesh — JSON fayl. Shuning uchun kanon bu darsda kod qo'shmadi va o'lchov bilan cheklandi (t29-buffer.txt). Lekin baytlar loyihaning bir necha joyida yashirin ishlaydi:

E'tibor bering: testdagi matn += b.toString() — «Bo'lingan belgi» bo'limidagi usul! Testda bu xavfsiz, chunki PassThrough ga har safar butun satr yoziladi va u bo'linmaydi. Lekin haqiqiy tarmoq oqimida xuddi shu qator ko'p baytli belgili kurs nomlarini (CBU CcyNm_UZ maydoni — 4-mashqqa qarang) ba'zan buzishi mumkin. Bu darsda commit yo'q.

8. Ko'p uchraydigan xatolar

9. Mashqlar

Mashqlar kurs/mashqlar/24/29-buffer/ da.

1-mashq (oson): hisoblang

• Buffer.byteLength("salom") —
• Buffer.byteLength("so'm") —
• "soʻm" necha bayt —
• Buffer.from("A").toString("hex") —
• URL uchun xavfsiz base64 nomi —

2-mashq (o'rta): SMS bo'laklari

SMS bitta xabarga 140 bayt sig'adi. smsParts(text) funksiyasini yozing: matnni UTF-8 baytlari 140 dan oshmaydigan bo'laklarga ajratsin va belgini o'rtasidan bo'lmasin. Maslahat: belgilar bo'yicha aylanib (for (const ch of text)), har belgining Buffer.byteLength ini qo'shib boring. Sinang: 100 ta "a" + 30 ta "ʻ" ("ʻ") + 20 ta "b".

function smsParts(text, limit = 140) {
  const parts = [];
  let current = "";
  let size = 0;
  for (const ch of text) {
    const bytes = Buffer.byteLength(ch);
    if (size + bytes > limit) {
      parts.push(current);
      current = "";
      size = 0;
    }
    current += ch;
    size += bytes;
  }
  if (current) parts.push(current);
  return parts;
}

const text = "a".repeat(100) + "\u02BB".repeat(30) + "b".repeat(20);
const parts = smsParts(text);
console.log(parts.length);
console.log(parts.map((p) => Buffer.byteLength(p)));
console.log(parts.map((p) => [...p].length));

2
[ 140, 40 ]
[ 120, 30 ]

3-mashq (qiyin): xabar paketi

Binar paket formati: 4 bayt — xabar uzunligi (UInt32BE), keyin xabarning UTF-8 baytlari. pack(text) va unpack(buf) yozing. unpack bir nechta paket ketma-ket turgan buferdan hamma xabarlarni qaytarsin. Sinang: "osh", "soʻm", "" — uchalasini Buffer.concat bilan birlashtirib, keyin unpack.

function pack(text) {
  const body = Buffer.from(text, "utf8");
  const header = Buffer.alloc(4);
  header.writeUInt32BE(body.length);
  return Buffer.concat([header, body]);
}

function unpack(buf) {
  const messages = [];
  let offset = 0;
  while (offset + 4 <= buf.length) {
    const length = buf.readUInt32BE(offset);
    const start = offset + 4;
    const body = buf.subarray(start, start + length);
    messages.push(body.toString("utf8"));
    offset = start + length;
  }
  return messages;
}

const packets = ["osh", "so\u02BBm", ""].map(pack);
const stream = Buffer.concat(packets);
console.log(stream.length);
console.log(packets[1]);
console.log(unpack(stream));

20
<Buffer 00 00 00 05 73 6f ca bb 6d>
[ 'osh', 'soʻm', '' ]

4-mashq: CLI qadami — kurs nomlarining baytlari

valyuta ning fixtures/kurslar-2026-10-23.json faylidagi har valyutaning CcyNm_UZ (o'zbekcha nomi) maydoni uchun belgi va bayt sonini hisoblang. Qaysi nomlarda bayt soni belgi sonidan katta? Ichida ʻ (U+02BB) bormi yoki oddiy '? Kichik skript yozing (loyihaga qo'shmang).

import { readFile } from "node:fs/promises";

const file = "fixtures/kurslar-2026-10-23.json";
const list = JSON.parse(await readFile(file, "utf8"));
for (const { Ccy, CcyNm_UZ } of list) {
  const chars = [...CcyNm_UZ].length;
  const bytes = Buffer.byteLength(CcyNm_UZ);
  if (bytes > chars) console.log(Ccy, chars, bytes, CcyNm_UZ);
}

AFN 21 25 Afg‘oniston afg‘onisi
KGS 12 14 Qirg‘iz somi
KZT 19 21 Qozog‘iston tengesi
SAR 24 26 Saudiya Arabistoni riali

10. Real ishda

• Fayl yuklash — rasm, PDF serverga baytlar bo'lib keladi; ularni Buffer yoki oqim sifatida qayta ishlash backend qismlarida.
• Tokenlar — JWT uch qismi base64url; Buffer.from(qism, "base64url") bilan ichini o'qish mumkin (auth qismida).
• Kriptografiya — hash, HMAC, kalitlar — hammasi Buffer; solishtirish crypto.timingSafeEqual(bufA, bufB) bilan.
• Kodlash muammolari — Excel'dan kelgan CSV (ko'pincha windows-1251 yoki BOM bilan), eski 1C eksportlari — "buzilgan harflar" shikoyatining asosiy manbai.
• Intervyuda: "length va byteLength farqi?", "subarray nusxa oladimi?", "base64 hajmni qanchaga oshiradi?".

Xulosa

• Buffer — baytlar massivi (Uint8Array asosida); Buffer.from(satr) UTF-8 bilan kodlaydi.
• alloc — xavfsiz (nollar), allocUnsafe — eski qoldiq bo'lishi mumkin; new Buffer — eskirgan.
• Kodlashlar: utf8, hex, base64 (+33 %), base64url (URL/JWT), latin1; o'qish va yozish kodlashi bir xil bo'lsin.
• length ≠ byteLength: ' — 1 bayt, ʻ — 2, — — 3, emoji — 4; joy baytda o'lchanadi.
• Bo'lak chegarasidagi ko'p baytli belgi toString da buziladi — StringDecoder, setEncoding yoki Buffer.concat.

Keyingi dars: Stream nima: to'rt turi va rejimlari — Buffer bo'laklari oqib keladigan quvurlar: Readable, Writable, Duplex, Transform.

Manbalar

• Node.js hujjati — Buffer (from, alloc, allocUnsafe, kodlashlar, byteLength, subarray va eskirgan slice, readUInt32BE, writeDoubleLE): https://nodejs.org/docs/latest-v24.x/api/buffer.html
• Node.js hujjati — String decoder: https://nodejs.org/docs/latest-v24.x/api/string_decoder.html
• MDN — TextEncoder, TextDecoder (stream: true): https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder/decode
• Unicode — U+02BB MODIFIER LETTER TURNED COMMA: https://www.unicode.org/charts/PDF/U02B0.pdf
• Kanon: natijalar/tajriba/t29-buffer.txt (Node 24.21.0, Windows 11, 2026-10-23); valyuta (kalit.ts, fayl.ts, interaktiv.test.ts). Bo'lingan belgi, SMS va paket misollari — biz ishga tushirdik (Node 24.21.0).