JavaScript BigInt. Katta Sonlar bilan Ishlash
JavaScript-da BigInt turi haqida batafsil qo'llanma, uning xususiyatlari, ishlatilishi va amaliy misollari bilan
So'nggi yangilanish: 2024-12-18Bugun sizlar bilan JavaScript-ning ajoyib xususiyatlaridan biri - BigInt haqida gaplashamiz. BigInt ES2020 (ES11) bilan kiritilgan bo'lib, u bizga juda katta sonlar bilan ishlash imkonini beradi. Keling, BigInt dunyosiga sayohatimizni boshlaymiz!
BigInt nima?
BigInt - bu JavaScript-da juda katta butun sonlarni ifodalash uchun ishlatiladigan primitive ma'lumot turi. U standart Number turidagi 2^53 - 1 chegarasidan katta sonlar bilan ishlash imkonini beradi.
Oddiy Number va BigInt o'rtasidagi farqni ko'raylik:
const kattaSon = 9007199254740991n; // BigInt
const oddiyKattaSon = 9007199254740991; // Number
console.log(kattaSon === oddiyKattaSon); // false
console.log(typeof kattaSon); // "bigint"
console.log(typeof oddiyKattaSon); // "number"
Bu misolda, kattaSon BigInt turi, oddiyKattaSon esa oddiy Number turidir. Ularning qiymati bir xil ko'rinsa-da, ular turli xil ma'lumot turlaridir.
BigInt yaratish usullari
BigInt qiymatini yaratishning ikki asosiy usuli mavjud:
- Butun son oxiriga 'n' qo'shish:
const bigInt1 = 1234567890123456789012345678901234567890n;
- BigInt() funksiyasidan foydalanish:
const bigInt2 = BigInt("1234567890123456789012345678901234567890");
const bigInt3 = BigInt(1234567890); // Kichikroq sonlar uchun
BigInt bilan arifmetik amallar
BigInt-lar bilan barcha asosiy arifmetik amallarni bajarish mumkin:
const a = 1234567890123456789n;
const b = 9876543210987654321n;
console.log(a + b); // 11111111111111111110n
console.log(a - b); // -8641975320864197532n
console.log(a * b); // 12193263111263526900986223731469970n
console.log(a / b); // 0n (BigInt faqat butun son natijalarni qaytaradi)
console.log(a % b); // 1234567890123456789n
console.log(a ** 2n); // 1524157875323883675049535156249n
E'tibor bering, BigInt-lar faqat butun sonli bo'lish natijasini qaytaradi.
BigInt cheklovlari
BigInt-lar juda foydali, lekin ularning ba'zi cheklovlari mavjud:
- BigInt-larni Number-lar bilan aralashtirib ishlatib bo'lmaydi:
const bigInt = 10n;
const number = 5;
// console.log(bigInt + number); // TypeError: Cannot mix BigInt and other types
console.log(bigInt + BigInt(number)); // 15n
- BigInt-lar Math obyekti metodlari bilan ishlamaydi:
// console.log(Math.max(5n, 10n)); // TypeError: Cannot convert a BigInt value to a number
console.log(5n > 10n ? 5n : 10n); // 10n (taqqoslash ishlaydi)
- BigInt-lar kasr qismini yo'qotadi:
console.log(5n / 2n); // 2n (3n emas)
BigInt-larni taqqoslash
BigInt-larni o'zaro va Number-lar bilan taqqoslash mumkin:
console.log(5n === 5); // false (turlar farq qiladi)
console.log(5n == 5); // true (qiymatlar teng)
console.log(10n > 5); // true
console.log(5n < 10); // true
console.log(5n <= 5); // true
console.log(5n >= 5); // true
BigInt-larni stringga o'tkazish
BigInt-larni stringga o'tkazish uchun toString() metodidan yoki oddiy string konvertatsiyasidan foydalanish mumkin:
const kattaSon = 1234567890123456789012345678901234567890n;
console.log(kattaSon.toString()); // "1234567890123456789012345678901234567890"
console.log(String(kattaSon)); // "1234567890123456789012345678901234567890"
console.log(kattaSon + ""); // "1234567890123456789012345678901234567890"
BigInt-larning amaliy qo'llanilishi
BigInt-lar quyidagi holatlarda juda foydali bo'lishi mumkin:
- Kriptografiya va xavfsizlik:
function kattaTubSonniTekshir(son) {
if (son <= 1n) return false;
for (let i = 2n; i * i <= son; i++) {
if (son % i === 0n) return false;
}
return true;
}
const kattaSon = 2n ** 256n - 1n; // Mersenne tub soni
console.log(kattaTubSonniTekshir(kattaSon)); // true
- Vaqt bilan ishlash (millisekundlar):
const boshlanishVaqti = BigInt(Date.now());
// Uzoq davom etadigan operatsiya
const tugashVaqti = BigInt(Date.now());
const farq = tugashVaqti - boshlanishVaqti;
console.log(`Operatsiya ${farq} millisekund davom etdi`);
- Katta sonli hisob-kitoblar:
function faktorial(n) {
if (n === 0n) return 1n;
return n * faktorial(n - 1n);
}
console.log(faktorial(50n)); // 30414093201713378043612608166064768844377641568960512000000000000n
BigInt-lar va JSON
BigInt-larni to'g'ridan-to'g'ri JSON-ga o'tkazib bo'lmaydi. Buning uchun maxsus yondashuv kerak:
const data = { kattaSon: 1234567890123456789012345678901234567890n };
const json = JSON.stringify(data, (key, value) =>
typeof value === 'bigint' ? value.toString() : value
);
console.log(json); // {"kattaSon":"1234567890123456789012345678901234567890"}
const parsedData = JSON.parse(json, (key, value) =>
key === 'kattaSon' ? BigInt(value) : value
);
console.log(parsedData.kattaSon); // 1234567890123456789012345678901234567890n
Xulosa
BigInt JavaScript-da katta sonlar bilan ishlash imkoniyatini beruvchi ajoyib xususiyatdir. U kriptografiya, aniq hisob-kitoblar va katta ma'lumotlar bilan ishlashda juda foydali. BigInt-larning o'ziga xos xususiyatlarini va cheklovlarini tushunish orqali siz ulardan to'g'ri va samarali foydalanishingiz mumkin.
Tez-tez so'raladigan savollar (FAQ)
- S: BigInt qachon ishlatilishi kerak? J: BigInt 2^53 - 1 dan katta yoki -2^53 + 1 dan kichik butun sonlar bilan ishlash kerak bo'lganda ishlatiladi. Bu asosan kriptografiya, katta sonli hisob-kitoblar va aniqlik muhim bo'lgan boshqa sohalarda qo'llaniladi.
- S: BigInt-larni Number-larga va aksincha o'tkazish mumkinmi? J: Ha, lekin ehtiyotkorlik bilan:
const bigInt = 123456789012345678901234567890n;
const number = Number(bigInt); // Aniqlik yo'qolishi mumkin
const backToBigInt = BigInt(Math.floor(number)); // Faqat butun son qismi olinadi
- S: BigInt-lar ishlash tezligiga qanday ta'sir qiladi? J: BigInt-lar odatda Number-larga qaraganda sekinroq ishlaydi, chunki ular kattaroq xotira talab qiladi va murakkab operatsiyalarni bajaradi. Katta sonlar bilan ishlashda BigInt-lar samaraliroq, lekin kichik sonlar uchun oddiy Number-larni ishlatish ma'qul.
- S: BigInt-lar barcha brauzerlarda qo'llab-quvvatlanadimi? J: BigInt-lar zamonaviy brauzerlarda qo'llab-quvvatlanadi, lekin eski versiyalarda muammo bo'lishi mumkin. Ishlatishdan oldin brauzer mosligini tekshirish yoki polyfill ishlatish tavsiya etiladi.
- S: BigInt-lar bilan kasrli sonlarni qanday ifodalash mumkin? J: BigInt-lar faqat butun sonlarni ifodalaydi. Kasrli sonlar bilan ishlash uchun, sonni kattalashtirish va keyin bo'lish usulidan foydalanish mumkin:
const kasr = 1234567890123456789n * 100n / 3n; // 411522630041152263n
console.log(kasr / 100n); // 4115226300411522n (41152263004115.22 taxminan)
- S: BigInt-lar xotirani ko'p ishg'ol qiladimi? J: Ha, BigInt-lar oddiy Number-larga qaraganda ko'proq xotira talab qiladi. Ular dinamik ravishda xotira ajratadi, shuning uchun juda katta sonlar ko'p xotira ishg'ol qilishi mumkin.
- S: BigInt-lar bilan ishlashda qanday xavfsizlik masalalarini hisobga olish kerak? J: BigInt-lar xavfsizlik nuqtai nazaridan muhim, ayniqsa kriptografik operatsiyalarda. Timing hujumlaridan himoyalanish uchun doimiy vaqtda ishlaydigan operatsiyalardan foydalanish kerak. Shuningdek, BigInt-larni oddiy raqamlarga o'tkazishda aniqlik yo'qolishi mumkinligini unutmang.
Bu savollar va javoblar BigInt-lar haqida ko'p uchraydigan savollarga oydinlik kiritadi va ulardan foydalanishda muhim nuqtalarni ta'kidlaydi.