JavaScript BigInt: juda katta butun sonlar bilan aniq ishlash

Qisqacha: BigInt — istalgan uzunlikdagi butun sonni aniq saqlaydigan maxsus tur. U son oxiriga n harfi qo'yib (123n) yoki BigInt("123") bilan yaratiladi. BigInt'ni oddiy son bilan bitta amalda aralashtirib bo'lmaydi — TypeError chiqadi. Bo'lishda kasr qism tashlab yuboriladi: 7n / 2n natijasi 3n.

Bu darsda

• Oddiy son qayerda "sinishini" va BigInt bu muammoni qanday hal qilishini tushunasiz.
• BigInt'ni n harfi va BigInt() bilan yarata olasiz.
• BigInt bilan qo'shish, ko'paytirish, bo'lish va taqqoslashni bajara olasiz.
• Cannot mix BigInt and other types xatosini tanib, to'g'ri tuzata olasiz.
• BigInt qachon kerak, qachon keraksiz ekanini ajrata olasiz.

Oldin bilishingiz kerak: Number turi: MAX_SAFE_INTEGER va boshqalar, Matn ↔ son va sonni tekshirish, Pul va aniq hisob-kitob.

1. Nega bu kerak?

Oldingi darsda pulni tiyinda, ya'ni butun sonda saqlashni o'rgandik. Butun son — ishonchli. Lekin butun sonning ham chegarasi bor.

Tasavvur qiling: onlayn do'kon serveri sizga buyurtma raqamini yubordi. Raqam uzun — 19 xonali:

const buyurtmaId = 1234567890123456789;
console.log(buyurtmaId); // 1234567890123456800

Oxirgi raqamlar 789 emas, 800 bo'lib qoldi! JavaScript hech qanday xato ko'rsatmadi. U jimgina boshqa sonni saqlab qo'ydi.

Endi shu raqam bilan buyurtmani qidirsangiz, boshqa odamning buyurtmasi chiqishi yoki hech narsa topilmasligi mumkin. Bunday xato eng xavflisi — chunki uni sezmay qolasiz.

Sababini Number turi darsida ko'rgan edik. Oddiy son butun sonlarni faqat Number.MAX_SAFE_INTEGER gacha aniq saqlaydi:

console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991

Bu taxminan 9 kvadrillion — 16 xonali son. Undan katta butun sonlar uchun JavaScript'da alohida tur bor — BigInt.

2. BigInt nima?

BigInt (inglizcha "big integer" — "katta butun son") — istalgan uzunlikdagi butun sonni aniq saqlaydigan tur.

Hayotdan o'xshatish. Oddiy son — kalkulyator ekraniga o'xshaydi. Ekranda 16 ta joy bor, kattaroq son sig'maydi va oxiri "yaxlitlanib" ketadi. BigInt esa daftarda ustun usulida hisoblashga o'xshaydi: qog'oz yetguncha istalgan uzunlikdagi sonni yozasiz. Faqat sekinroq.

2.1 n harfi bilan yozish

BigInt yaratishning eng qisqa yo'li — butun son oxiriga n harfini qo'yish:

const buyurtmaId = 1234567890123456789n;
console.log(buyurtmaId); // 1234567890123456789n
console.log(typeof buyurtmaId); // bigint

Endi hamma raqam joyida. Node konsolda BigInt oxirida n bilan ko'rinadi — bu uni oddiy sondan ajratib turadi. Brauzer konsoli ham xuddi shunday 1234567890123456789n deb ko'rsatadi.

typeof natijasi — "bigint". Bu ma'lumot turlari xaritasidagi 7 ta primitivdan biri.

Son yozish shakllari darsidagi qulayliklar BigInt'da ham ishlaydi:

console.log(1_000_000n); // 1000000n
console.log(0xffn); // 255n

_ ajratgich faqat o'qish uchun, 0x esa o'n oltilik yozuv. Oxiriga n qo'shilsa — BigInt bo'ladi.

Diqqat: n faqat butun songa qo'yiladi. 1.5n deb yozsangiz, SyntaxError: Invalid or unexpected token chiqadi. BigInt'da kasr son bo'lmaydi.

2.2 BigInt() bilan yaratish

Ikkinchi yo'l — tayyor BigInt() funksiyasi. U xuddi Number() kabi ishlaydi: qavs ichidagi qiymatni BigInt'ga aylantiradi.

console.log(BigInt("1234567890123456789")); // 1234567890123456789n
console.log(BigInt(42)); // 42n
console.log(BigInt(true)); // 1n

Bu usul qachon kerak? Katta son ko'pincha tashqaridan satr bo'lib keladi: formadan, fayldan yoki serverdan. Uni BigInt("...") bilan aylantirasiz va hech bir raqam yo'qolmaydi.

Lekin ikki holatda BigInt() xato beradi:

console.log(BigInt(1.5));

RangeError: The number 1.5 cannot be converted to a BigInt because it is not an integer

Tarjimasi: "1.5 sonini BigInt'ga aylantirib bo'lmaydi, chunki u butun son emas". RangeError — "qiymat ruxsat etilgan chegaradan tashqarida" degan xato turi. BigInt faqat butun sonni qabul qiladi.

console.log(BigInt("abc"));

SyntaxError: Cannot convert abc to a BigInt

Tarjimasi: "abc ni BigInt'ga aylantirib bo'lmaydi". E'tibor bering: Number("abc") jimgina NaN qaytarardi. BigInt esa darhol xato beradi — BigInt'da NaN degan qiymat yo'q.

Tekshirib ko'ring: Qaysi qatorlar xato beradi? BigInt("500"), BigInt(2.5), BigInt("12a"), 100n.

2.3 Tuzoq: katta sonni BigInt() ga son sifatida berish

Bu xato juda ko'p uchraydi, chunki kod to'g'riga o'xshaydi:

console.log(BigInt(9007199254740993)); // 9007199254740992n

Oxirgi raqam 3 emas, 2! Nega? Chunki JavaScript avval 9007199254740993 ni oddiy son sifatida o'qiydi. Shu paytning o'zida u buzilib, ...992 ga aylanadi. BigInt() ga allaqachon buzilgan son yetib keladi.

To'g'ri yo'llar — son oddiy songa aylanmasdan BigInt bo'lsin:

console.log(9007199254740993n); // 9007199254740993n
console.log(BigInt("9007199254740993")); // 9007199254740993n

Qoida: katta sonni BigInt() ga faqat satr ko'rinishida bering. Kichik sonlarni (BigInt(42)) son bilan berish xavfsiz.

3. BigInt bilan amallar

3.1 Qo'shish, ayirish, ko'paytirish, daraja

Arifmetik operatorlar BigInt bilan ham ishlaydi. Faqat ikkala tomon ham BigInt bo'lishi kerak.

Qadimiy rivoyat bor. Shaxmatni o'ylab topgan donishmand podshohdan mukofot so'rabdi: "Birinchi katakka 1 dona bug'doy, ikkinchisiga 2, uchinchisiga 4 qo'ying. Har katakka oldingisidan ikki barobar ko'p". Podshoh kulibdi. Keyin hisoblab ko'rishibdi.

64 ta katakdagi jami bug'doy — 2 ning 64-darajasidan 1 kam:

const bugdoy = 2n ** 64n - 1n;
console.log(bugdoy); // 18446744073709551615n

18 kvintillion dona! Butun dunyo bir necha yuz yilda shuncha bug'doy yetishtirmaydi. Endi xuddi shu hisobni oddiy son bilan qilamiz:

console.log(2 ** 64 - 1); // 18446744073709552000

Oddiy son javobni "taxminan" berdi: oxirida 552000. BigInt esa har bir donagacha aniq sanadi.

Boshqa amallar ham odatdagidek:

console.log(10n + 5n); // 15n
console.log(10n - 20n); // -10n
console.log(4000000000n * 3000000000n); // 12000000000000000000n
console.log(-5n); // -5n

Minus ishorasi ham, manfiy natija ham bor. BigInt faqat kasr qismni bilmaydi.

3.2 Bo'lish: kasr qism tashlab yuboriladi

Oddiy sonda 7 / 2 natijasi 3.5. BigInt'da kasr bo'lmagani uchun natija boshqacha:

console.log(7n / 2n); // 3n
console.log(-7n / 2n); // -3n
console.log(7n % 2n); // 1n

BigInt bo'lishda kasr qismni shunchaki kesib tashlaydi. Yaxlitlamaydi: 3.5 ham 3n bo'ladi, 3.9 ham. Manfiy sonda ham nolga qarab kesadi: -3.5 → -3n. Bu Math darsidagi Math.trunc ga o'xshaydi.

Qoldiqni esa % bilan olasiz — oddiy sondagidek.

Hayotiy misol: 10 ta non 3 kishiga bo'linadi. Har kim butun non oladi, bo'lak kesilmaydi:

const nonlar = 10n;
const odamlar = 3n;

console.log(nonlar / odamlar); // 3n
console.log(nonlar % odamlar); // 1n

Har kishiga 3 tadan non tegadi, 1 ta ortib qoladi.

Diqqat: Oddiy sonda 5 / 0 natijasi Infinity edi. BigInt'da nolga bo'lish xato beradi: RangeError: Division by zero ("nolga bo'lish"). BigInt'da Infinity yo'q.

Tekshirib ko'ring: Bo'sh joylarni to'ldiring.

25n / 10n natijasi [:2n], 25n % 10n natijasi [:5n].

3.3 Taqqoslash

Taqqoslash operatorlari BigInt bilan ham, hatto BigInt va oddiy son orasida ham ishlaydi:

console.log(10n > 9); // true
console.log(1n < 1.5); // true
console.log(10n == 10); // true
console.log(10n === 10); // false

Oxirgi ikki qatorga e'tibor bering. Ikki belgili == faqat qiymatga qaraydi: ikkalasi ham "o'n". Uch belgili === esa turni ham tekshiradi: bigint va number — ikki xil tur. Tenglik darsidagi qoida shu yerda ham amal qiladi. Doim === ishlating va turlarni o'zingiz bir xil qiling.

Yana bir eslatma: 0n — 8 ta falsy qiymatdan biri. Qolgan hamma BigInt truthy.

3.4 Nima ishlamaydi?

BigInt bilan hamma narsa ham ishlamaydi. Uchtasini eslab qoling.

Birinchi: unar plyus (+5n) xato beradi. Ikkinchi: Math funksiyalari faqat oddiy son bilan ishlaydi:

console.log(Math.max(1n, 2n));

TypeError: Cannot convert a BigInt value to a number

Tarjimasi: "BigInt qiymatini oddiy songa aylantirib bo'lmaydi". Math.max ichida oddiy son kutadi va BigInt'ni o'zi aylantirishga urinadi. JavaScript esa BigInt'ni jimgina aylantirishga ruxsat bermaydi. +5n ham aynan shu xatoni beradi.

Uchinchi: >>> bitli operatori (bitwise darsida ko'rgan) BigInt'da yo'q. Qolgan bitli operatorlar (&, |, <<, >>) ishlaydi.

4. Oddiy son bilan aralashtirib bo'lmaydi

4.1 Xato va uning sababi

Bu BigInt'ning eng muhim qoidasi. Do'konda 3 ta mahsulot sotildi, narxi BigInt'da saqlangan:

const narx = 5000n;
const soni = 3;

console.log(narx * soni);

TypeError: Cannot mix BigInt and other types, use explicit conversions

Tarjimasi: "BigInt'ni boshqa turlar bilan aralashtirib bo'lmaydi, aniq (explicit) aylantirishdan foydalaning".

Nega JavaScript o'zi aylantirib qo'ya qolmaydi? Chunki ikkala yo'l ham xavfli:

• BigInt'ni oddiy songa aylantirsa — katta son buziladi (1-bo'limdagi ...800 kabi).
• Oddiy sonni BigInt'ga aylantirsa — 1.5 kabi kasr son sig'maydi.

Qaysi biri to'g'ri ekanini faqat siz bilasiz. Shuning uchun JavaScript taxmin qilmaydi — sizdan aniq aylantirishni talab qiladi. Bu yaxshi: xato jim qolmaydi, darhol ko'rinadi.

4.2 Qanday tuzatiladi?

Turlarni aniq o'zgartirish darsida ko'rgan usul: bittasini ikkinchisining turiga aylantirasiz.

const narx = 5000n;
const soni = 3;

console.log(narx * BigInt(soni)); // 15000n
console.log(Number(narx) * soni); // 15000

Birinchi qatorda soni BigInt'ga aylandi — natija BigInt. Ikkinchi qatorda narx oddiy songa aylandi — natija oddiy son.

Qaysi birini tanlash kerak? Qoida bitta: son katta bo'lishi mumkin bo'lsa — hammasini BigInt'ga aylantiring. Number() ga aylantirish katta sonni buzadi:

const katta = 12345678901234567890n;
console.log(Number(katta)); // 12345678901234567000

Number() xato bermadi, lekin oxirgi raqamlar yo'qoldi. Shuning uchun Number() ni faqat son xavfsiz chegaradan (Number.MAX_SAFE_INTEGER) kichik ekaniga ishonchingiz komil bo'lsa ishlating.

4.3 Satr bilan esa ishlaydi

Bitta istisno bor: satr bilan + qilsangiz, BigInt satrga aylanadi va xato chiqmaydi:

const id = 123n;

console.log("ID: " + id); // ID: 123
console.log(`ID: ${id}`); // ID: 123
console.log(String(id)); // 123

Satrga aylanganda n harfi yo'qoladi — satrda faqat raqamlar qoladi. Template literal ham bemalol ishlaydi.

Tekshirib ko'ring: Qaysi qatorlar xato beradi va nega? 10n + 5n, 10n + 5, "10" + 5n, 10n > 5.

5. BigInt va JSON

Server va brauzer bir-biriga ma'lumotni matn ko'rinishida yuboradi. Buning eng mashhur formati — JSON (JavaScript Object Notation — "JavaScript obyekt yozuvi"). Qiymatni JSON matniga JSON.stringify() aylantiradi. JSON'ni alohida darsda to'liq o'rganamiz, hozir bitta narsa muhim:

console.log(JSON.stringify(500)); // 500
console.log(JSON.stringify("Toshkent")); // "Toshkent"

Oddiy son va satr muammosiz aylandi. BigInt esa:

const id = 1234567890123456789n;
console.log(JSON.stringify(id));

TypeError: Do not know how to serialize a BigInt

Tarjimasi: "BigInt'ni qanday seriyalashni bilmayman". Seriyalash (serialize) — qiymatni yuborish yoki saqlash uchun matnga aylantirish. JSON formatida BigInt uchun joy yo'q. Uni oddiy songa aylantirsa — katta raqamlar buziladi. Shuning uchun JavaScript xato beradi.

Yechim — BigInt'ni oldindan satrga aylantirib yuborish:

const id = 1234567890123456789n;
console.log(JSON.stringify(String(id))); // "1234567890123456789"

Qabul qiluvchi tomon uni BigInt("...") bilan qaytadan BigInt qiladi. Katta kompaniyalarning API'lari (dasturlar bir-biri bilan ma'lumot almashadigan "eshik") aynan shunday qiladi. Masalan, X (sobiq Twitter) har bir postning ID'sini ham son, ham satr (id_str) ko'rinishida beradi. Dasturchilar satrdagisini ishlatadi.

Maslahat: JSON'ni sozlab, BigInt'ni avtomatik satrga aylantirish usuli ham bor. Uni JSON chuqur darsida ko'ramiz.

6. BigInt qachon kerak, qachon kerak emas?

BigInt — maxsus asbob. Kundalik hisob-kitobning 99 foizida oddiy son yetadi.

BigInt nega hamma joyda ishlatilmaydi? Uchta sabab bor:

• Sekinroq. Kompyuter oddiy son bilan bir amalda ishlaydi, BigInt bilan esa "ustun usulida".
• Kasr yo'q. Foiz yoki o'rtacha qiymat hisoblashda noqulay.
• Aralashtirib bo'lmaydi. Har amalda turlarni kuzatib borish kerak, Math ishlamaydi.

Kriptovalyutadan misol. Ethereum'da eng kichik birlik — wei. 1 ETH = 10 ning 18-darajasi wei. Hamyonda 1.5 ETH bo'lsa, u wei'da saqlanadi:

const wei = 1_500_000_000_000_000_000n;
const birEth = 10n ** 18n;

console.log(wei / birEth); // 1n
console.log(wei % birEth); // 500000000000000000n

Butun qismi — 1 ETH, qoldig'i — yarim ETH wei'da. Bu xuddi pul darsidagi so'm va tiyin g'oyasi. Faqat sonlar ancha katta.

Faktorialdan misol. 20! — 1 dan 20 gacha sonlar ko'paytmasi — 2432902008176640000. Bu allaqachon xavfsiz chegaradan katta. 25! ni esa oddiy son umuman aniq saqlay olmaydi. Uni for sikli darsida BigInt bilan hisoblaymiz.

7. Ko'p uchraydigan xatolar

7.1 BigInt va oddiy sonni aralashtirish

TypeError: Cannot mix BigInt and other types, use explicit conversions — eng ko'p uchraydigan xato. Tuzatish: bitta turga keltiring, odatda BigInt(son) bilan. 4-bo'limga qarang.

7.2 Katta sonni BigInt() ga son bilan berish

BigInt(9007199254740993) → 9007199254740992n. Xato chiqmaydi, lekin son buzilgan. Katta sonni n bilan yozing yoki satr bilan bering: BigInt("9007199254740993").

7.3 Bo'lishda kasr kutish

const jami = 10n;
console.log(jami / 4n); // 2n

Kutilgani 2.5, natija esa 2n. BigInt kasrni tashlab yuboradi. Kasr kerak bo'lsa — oddiy son ishlating yoki qoldiqni % bilan alohida oling.

7.4 Math funksiyalarini BigInt bilan ishlatish

Math.max(1n, 2n), Math.sqrt(16n) — TypeError: Cannot convert a BigInt value to a number. Math faqat oddiy son uchun. BigInt uchun kerakli amalni o'zingiz yozasiz (masalan, taqqoslashni > bilan).

7.5 BigInt'ni JSON'ga to'g'ridan-to'g'ri berish

TypeError: Do not know how to serialize a BigInt. Oldin String(id) bilan satrga aylantiring.

7.6 new BigInt(...) deb yozish

Ba'zi tayyor funksiyalar oldiga new so'zi yoziladi. Buni klasslar mavzusida o'rganamiz, hozir bilish shart emas. BigInt bilan esa bunday qilmang:

const son = new BigInt(5);

TypeError: BigInt is not a constructor

Tarjimasi: "BigInt konstruktor emas" — ya'ni uni new bilan chaqirib bo'lmaydi. Shunchaki BigInt(5) yoki 5n deb yozing.

8. Mashqlar

1-mashq (oson): Xatoni tuzating

Quyidagi kod xato beradi. Uni shunday tuzatingki, jami narx BigInt bo'lib chiqsin: 45000n.

const bitNarxi = 15000n;
const bitlarSoni = 3;

console.log(bitNarxi * bitlarSoni);

Ishora: oddiy sonni BigInt() bilan aylantiring (4.2-bo'limdagidek).

const bitNarxi = 15000n;
const bitlarSoni = 3;

console.log(bitNarxi * BigInt(bitlarSoni)); // 45000n

2-mashq (o'rta): Shaxmat va bug'doy

Shaxmat taxtasining 30-katagida qancha bug'doy bor? Birinchi katakda 1 dona, har keyingisida ikki barobar ko'p. Demak, 30-katakda 2 ning 29-darajasi.

1. Uni oddiy son bilan hisoblang (2 ** 29).
2. BigInt bilan hisoblang.
3. Xuddi shu ishni 64-katak uchun qiling (2 ning 63-darajasi) — ikkala usulda.

Qaysi katakda oddiy son "adashadi"? ** — daraja operatori.

console.log(2 ** 29); // 536870912
console.log(2n ** 29n); // 536870912n

console.log(2 ** 63); // 9223372036854776000
console.log(2n ** 63n); // 9223372036854775808n

3-mashq (qiyin): Serverdan kelgan ID

Server onlayn do'kondagi buyurtmaning ID raqamini satr ko'rinishida yubordi: "9007199254740993". Sizning vazifangiz:

1. ID'ni BigInt'ga aylantiring (raqamlar buzilmasin).
2. Keyingi buyurtmaning ID'sini hisoblang — bittaga katta.
3. Yangi ID'ni serverga yuborish uchun JSON matniga aylantiring (xato chiqmasin).
4. Taqqoslash uchun: xuddi shu satrni Number() bilan aylantirib, unga 1 qo'shing va natijani chiqaring.

Ishora: BigInt("..."), String(...) va JSON.stringify(...) — 2.2, 4.3 va 5-bo'limlarda.

const idMatn = "9007199254740993";

const id = BigInt(idMatn);
const keyingiId = id + 1n;

console.log(id); // 9007199254740993n
console.log(keyingiId); // 9007199254740994n
console.log(JSON.stringify(String(keyingiId))); // "9007199254740994"

console.log(Number(idMatn) + 1); // 9007199254740992

9. Real ishda

• Ma'lumotlar bazasi. PostgreSQL'da BIGINT degan ustun turi bor — 19 xonagacha butun son. Node.js uchun pg kutubxonasi bunday ustunni sukut bo'yicha satr qilib beradi. Sababi — siz hozir ko'rgan muammo. Bazalarni kursda alohida qismda o'rganamiz.
• Katta ID'lar. Discord, X kabi platformalar 64-bitli ID ishlatadi — ular xavfsiz chegaradan katta. Bunday API bilan ishlaganda ID'ni satr yoki BigInt'da saqlaysiz.
• Kriptografiya va blokcheyn. Shifrlash algoritmlari yuzlab xonali sonlar bilan ishlaydi. Kriptovalyuta hamyonlari balansni eng kichik birlikda BigInt bilan saqlaydi.
• Vaqtni aniq o'lchash. Node.js'da process.hrtime.bigint() vaqtni nanosekundda BigInt qilib beradi. Kod qancha tez ishlashini o'lchashda ishlatiladi.
• Intervyu. "0.1 + 0.2 nega 0.3 emas?" savolidan keyin ko'pincha "juda katta butun son bilan qanday ishlaysiz?" deb so'rashadi. Javob: Number.MAX_SAFE_INTEGER dan katta bo'lsa — BigInt, oddiy son bilan aralashtirmaslik, JSON'da satr qilib yuborish.

Xulosa

• Oddiy son butun sonni faqat Number.MAX_SAFE_INTEGER (16 xonali) gacha aniq saqlaydi. Undan kattasi jimgina buziladi.
• BigInt istalgan uzunlikdagi butun sonni aniq saqlaydi: 123n yoki BigInt("123"). typeof — "bigint".
• Katta sonni BigInt() ga faqat satr bilan bering: BigInt(9007199254740993) allaqachon buzilgan.
• Bo'lishda kasr tashlab yuboriladi: 7n / 2n → 3n. Math funksiyalari ishlamaydi.
• BigInt va oddiy sonni bitta amalda aralashtirib bo'lmaydi — BigInt() yoki Number() bilan aniq aylantiring.
• JSON BigInt'ni bilmaydi — String(id) bilan satr qilib yuboring.

Keyingi dars: if / else if / else — dastur birinchi marta shartga qarab turli yo'ldan borishni o'rganadi.