JavaScript'ning BigInt turiga oid keng qamrovli qo'llanma. Uning xususiyatlari, ishlatilishi va katta butun sonlar arifmetikasida qo'llanilishini o'rganing. JavaScript cheklovlarini yengib o'tishni va murakkab hisob-kitoblarni aniqlik bilan bajarishni o'rganing.
JavaScript BigInt: Katta Butun Sonlar Arifmetikasini O'zlashtirish
JavaScript ko'p qirrali til bo'lishiga qaramay, juda katta butun sonlar bilan ishlashda o'z cheklovlariga ega. Standart `Number` turi faqat `Number.MAX_SAFE_INTEGER` deb nomlanuvchi ma'lum bir chegaragacha bo'lgan butun sonlarni aniq ifodalay oladi. Bu chegaradan oshib ketganda, hisob-kitoblar noaniq bo'lib, kutilmagan natijalarga olib keladi. Aynan shu yerda BigInt yordamga keladi. ECMAScript 2020 da taqdim etilgan BigInt — bu standart `Number` turining cheklovlaridan oshib, ixtiyoriy hajmdagi butun sonlarni ifodalash va ular bilan ishlash imkonini beruvchi o'rnatilgan obyektdir.
BigInt'ga bo'lgan Ehtiyojni Tushunish
BigInt paydo bo'lishidan oldin, JavaScript dasturchilari katta butun sonli hisob-kitoblarni amalga oshirish uchun kutubxonalar yoki maxsus yechimlarga tayanishlari kerak edi. Bu yechimlar ko'pincha ishlash samaradorligini pasaytirar va murakkablikni oshirar edi. BigIntning joriy etilishi katta butun sonlar bilan ishlashning tabiiy va samarali usulini taqdim etdi va bu turli sohalarda qo'llanilish imkoniyatlarini ochdi, jumladan:
- Kriptografiya: Kriptografik algoritmlar uchun katta tub sonlar bilan xavfsiz ishlash juda muhim.
- Moliyaviy Hisob-kitoblar: Katta pul qiymatlarini aniqlikni yo'qotmasdan to'g'ri ifodalash.
- Ilmiy Hisoblashlar: Juda katta yoki kichik sonlarni o'z ichiga olgan murakkab hisob-kitoblarni bajarish.
- Yuqori Aniqlikdagi Vaqt Belgilari: Vaqt belgilarini nanosekund aniqlikda ifodalash.
- ID Generatsiyasi: Noyob va juda katta identifikatorlarni yaratish.
BigInt Qiymatlarini Yaratish
JavaScript'da BigInt qiymatlarini yaratishning ikkita asosiy usuli mavjud:
- `BigInt()` konstruktoridan foydalanish: Ushbu konstruktor son, satr yoki mantiqiy qiymatni
BigIntga o'zgartira oladi. - `n` qo'shimchasidan foydalanish: Butun sonli literalga `n` qo'shimchasini qo'shish
BigIntyaratadi.
Misollar:
`BigInt()` konstruktoridan foydalanish:
const bigIntFromNumber = BigInt(12345678901234567890);
const bigIntFromString = BigInt("98765432109876543210");
const bigIntFromBoolean = BigInt(true); // Natija 1n
const bigIntFromFalseBoolean = BigInt(false); // Natija 0n
console.log(bigIntFromNumber); // Chiqish: 12345678901234567890n
console.log(bigIntFromString); // Chiqish: 98765432109876543210n
console.log(bigIntFromBoolean); // Chiqish: 1n
console.log(bigIntFromFalseBoolean); // Chiqish: 0n
`n` qo'shimchasidan foydalanish:
const bigIntLiteral = 12345678901234567890n;
console.log(bigIntLiteral); // Chiqish: 12345678901234567890n
Muhim Eslatma: Arifmetik amallarda BigInt va Number qiymatlarini to'g'ridan-to'g'ri aralashtirib bo'lmaydi. Hisob-kitoblarni bajarishdan oldin ularni bir xil turga aniq o'zgartirishingiz kerak. Ularni to'g'ridan-to'g'ri aralashtirishga urinish `TypeError` xatoligiga olib keladi.
BigInt Arifmetik Amallari
BigInt standart arifmetik operatorlarning ko'pini qo'llab-quvvatlaydi, jumladan:
- Qo'shish (`+`)
- Ayirish (`-`)
- Ko'paytirish (`*`)
- Bo'lish (`/`)
- Qoldiq (`%`)
- Darajaga ko'tarish (`**`)
Misollar:
const a = 12345678901234567890n;
const b = 98765432109876543210n;
const sum = a + b;
const difference = a - b;
const product = a * b;
const quotient = a / 2n; // Eslatma: Bo'lish nolga qarab yaxlitlaydi
const remainder = a % 7n;
const power = a ** 3n; // Darajaga ko'tarish kutilgandek ishlaydi
console.log("Sum:", sum); // Chiqish: Sum: 111111111011111111100n
console.log("Difference:", difference); // Chiqish: Difference: -86419753208641975320n
console.log("Product:", product); // Chiqish: Product: 1219326311370217957951669538098765432100n
console.log("Quotient:", quotient); // Chiqish: Quotient: 6172839450617283945n
console.log("Remainder:", remainder); // Chiqish: Remainder: 5n
console.log("Power:", power); // Chiqish: Power: 187641281029182300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n
Muhim Mulohazalar:
- Bo'lish:
BigIntqiymatlari bilan bo'lish nolga qarab yaxlitlaydi. Bu natijaning kasr qismi tashlab yuborilishini anglatadi. Agar sizga aniqroq bo'lish kerak bo'lsa, ixtiyoriy aniqlikdagi arifmetikani qo'llab-quvvatlaydigan kutubxonalardan foydalanishni o'ylab ko'ring. - Unar Plyus Operatori (+): Unar plyus operatori (+)
BigIntqiymatlari bilan ishlatilishi mumkin emas, chunki u eski asm.js kodi bilan ziddiyatga kelishi mumkin. Agar sizga raqamli ifoda kerak bo'lsa (aniqlikni yo'qotishingiz mumkinligini tushungan holda), BigInt'ni Number'ga o'zgartirish uchun `Number()` konvertatsiya funksiyasidan foydalaning. - Bitwise Operatorlar:
BigIntshuningdek `&`, `|`, `^`, `~`, `<<`, va `>>` kabi bitwise operatorlarni ham qo'llab-quvvatlaydi. Bu operatorlarBigIntqiymatlarining ikkilik ifodasi ustida kutilganidek ishlaydi.
Taqqoslash Operatorlari
BigInt qiymatlarini boshqa BigInt yoki hatto Number qiymatlari bilan solishtirish uchun standart taqqoslash operatorlaridan (`==`, `!=`, `<`, `>`, `<=`, `>=`) foydalanishingiz mumkin. Biroq, tur o'zgarishi ehtimolidan ehtiyot bo'ling.
Misollar:
const a = 10n;
const b = 20n;
const c = 10;
console.log(a == b); // Chiqish: false
console.log(a != b); // Chiqish: true
console.log(a < b); // Chiqish: true
console.log(a > b); // Chiqish: false
console.log(a <= b); // Chiqish: true
console.log(a >= b); // Chiqish: false
console.log(a == c); // Chiqish: true (tur o'zgarishi)
console.log(a === c); // Chiqish: false (tur o'zgarishi yo'q)
Eng Yaxshi Amaliyot: BigInt va Number qiymatlarini solishtirganda kutilmagan tur o'zgarishlarini oldini olish uchun qat'iy tenglik (`===`) va qat'iy tengsizlikdan (`!==`) foydalaning.
BigInt va Number O'rtasida Konvertatsiya
BigInt va Number o'rtasida to'g'ridan-to'g'ri arifmetik amallarga ruxsat berilmagan bo'lsa-da, siz bu ikki tur o'rtasida konvertatsiya qilishingiz mumkin. Biroq, agar BigInt qiymati `Number.MAX_SAFE_INTEGER` dan oshsa, BigIntni Numberga o'zgartirganda aniqlikni yo'qotish ehtimoli borligini yodda tuting.
Misollar:
const bigIntValue = 9007199254740991n; // Number.MAX_SAFE_INTEGER
const numberValue = Number(bigIntValue); // BigInt'ni Number'ga o'zgartirish
console.log(numberValue); // Chiqish: 9007199254740991
const largerBigIntValue = 9007199254740992n; // Number.MAX_SAFE_INTEGER'dan oshadi
const largerNumberValue = Number(largerBigIntValue);
console.log(largerNumberValue); // Chiqish: 9007199254740992 (noaniq bo'lishi mumkin)
const numberToBigInt = BigInt(12345); // Number'ni BigInt'ga o'zgartirish
console.log(numberToBigInt); // Chiqish: 12345n
Qo'llanilish Holatlari va Misollar
Kriptografiya
Kriptografik algoritmlar ko'pincha xavfsizlik uchun juda katta tub sonlarga tayanadi. BigInt bu sonlarni samarali ifodalash va ular bilan ishlash imkonini beradi.
// Misol: Oddiy (xavfsiz bo'lmagan) kalit juftligini yaratish
function generateKeyPair() {
const p = 281n; // Bir tub son
const q = 283n; // Boshqa bir tub son
const n = p * q; // Modul
const totient = (p - 1n) * (q - 1n); // Eylerning totient funksiyasi
// 1 < e < totient va EKUB(e, totient) = 1 shartlarini qanoatlantiruvchi e (ochiq eksponenta) ni tanlang
const e = 17n;
// (d * e) % totient = 1 shartini qanoatlantiruvchi d (yopiq eksponenta) ni hisoblang
let d = 0n;
for (let i = 1n; i < totient; i++) {
if ((i * e) % totient === 1n) {
d = i;
break;
}
}
return {
publicKey: { n, e },
privateKey: { n, d },
};
}
const keyPair = generateKeyPair();
console.log("Public Key:", keyPair.publicKey);
console.log("Private Key:", keyPair.privateKey);
Eslatma: Bu faqat namoyish maqsadlari uchun soddalashtirilgan misol. Haqiqiy kriptografiyada ancha katta tub sonlar va murakkabroq algoritmlar qo'llaniladi.
Moliyaviy Hisob-kitoblar
Katta pul summalari bilan, ayniqsa xalqaro tranzaktsiyalarda ishlaganda, aniqlik juda muhim. BigInt yaxlitlash xatolarining oldini oladi va aniq hisob-kitoblarni ta'minlaydi.
// Misol: Murakkab foizlarni hisoblash
function calculateCompoundInterest(principal, rate, time) {
const principalBigInt = BigInt(principal * 100); // Sentlarga o'tkazish
const rateBigInt = BigInt(rate * 10000); // Foizning o'n mingdan biriga o'tkazish
const timeBigInt = BigInt(time);
let amount = principalBigInt;
for (let i = 0n; i < timeBigInt; i++) {
amount = amount * (10000n + rateBigInt) / 10000n;
}
const amountInDollars = Number(amount) / 100;
return amountInDollars;
}
const principal = 1000000; // $1,000,000
const rate = 0.05; // 5% foiz stavkasi
const time = 10; // 10 yil
const finalAmount = calculateCompoundInterest(principal, rate, time);
console.log("Final Amount:", finalAmount); // Chiqish: Final Amount: 1628894.6267774413 (taxminan)
Bu misolda biz hisoblash paytida yaxlitlash xatolarini oldini olish uchun asosiy summa va stavkani BigInt qiymatlariga o'zgartirdik. Natija esa ko'rsatish uchun Numberga qayta o'zgartiriladi.
Katta ID'lar bilan Ishlash
Taqsimlangan tizimlarda bir nechta serverlar bo'ylab noyob ID'larni yaratish qiyin bo'lishi mumkin. BigIntdan foydalanish to'qnashish ehtimoli kam bo'lgan juda katta ID'larni yaratishga imkon beradi.
// Misol: Vaqt belgisi va server ID'si asosida noyob ID yaratish
function generateUniqueId(serverId) {
const timestamp = BigInt(Date.now());
const serverIdBigInt = BigInt(serverId);
const random = BigInt(Math.floor(Math.random() * 1000)); // Bir oz tasodifiylik qo'shish
// Noyob ID yaratish uchun qiymatlarni birlashtirish
const uniqueId = (timestamp << 20n) + (serverIdBigInt << 10n) + random;
return uniqueId.toString(); // Oson ishlash uchun satr sifatida qaytarish
}
const serverId = 123; // Misol server ID'si
const id1 = generateUniqueId(serverId);
const id2 = generateUniqueId(serverId);
console.log("Unique ID 1:", id1);
console.log("Unique ID 2:", id2);
BigInt va JSON
BigInt qiymatlari JSON tomonidan tabiiy ravishda qo'llab-quvvatlanmaydi. JSON.stringify() yordamida BigIntni o'z ichiga olgan JavaScript obyektini seriyalashtirishga urinish `TypeError` xatoligiga olib keladi. JSON bilan ishlaganda BigInt qiymatlarini qayta ishlash uchun sizda bir nechta variant bor:
- Satrga O'zgartirish: Seriyalashtirishdan oldin
BigIntni satrga o'zgartiring. Bu eng keng tarqalgan va oddiy yondashuv. - Maxsus Seriyalashtirish/Deserializatsiya:
BigIntqiymatlarini qayta ishlash uchun maxsus seriyalashtirish/deserializatsiya funksiyasidan foydalaning.
Misollar:
Satrga O'zgartirish:
const data = {
id: 12345678901234567890n,
name: "Example Data",
};
// Seriyalashtirishdan oldin BigInt'ni satrga o'zgartirish
data.id = data.id.toString();
const jsonData = JSON.stringify(data);
console.log(jsonData); // Chiqish: {"id":"12345678901234567890","name":"Example Data"}
// Deserializatsiya qilganda, satrni BigInt'ga qayta o'zgartirishingiz kerak bo'ladi
const parsedData = JSON.parse(jsonData, (key, value) => {
if (key === "id") {
return BigInt(value);
}
return value;
});
console.log(parsedData.id); // Chiqish: 12345678901234567890n
Maxsus Seriyalashtirish/Deserializatsiya (`replacer` va `reviver` yordamida):
const data = {
id: 12345678901234567890n,
name: "Example Data",
};
// Maxsus seriyalashtirish
const jsonData = JSON.stringify(data, (key, value) => {
if (typeof value === 'bigint') {
return value.toString();
} else {
return value;
}
});
console.log(jsonData);
// Maxsus deserializatsiya
const parsedData = JSON.parse(jsonData, (key, value) => {
if (typeof value === 'string' && /^[0-9]+$/.test(value)) { //uning son va satr ekanligini tekshirish
try {
return BigInt(value);
} catch(e) {
return value;
}
}
return value;
});
console.log(parsedData.id);
Brauzerlarga Mosligi
BigInt zamonaviy brauzerlarda keng qo'llab-quvvatlanadi. Biroq, eski brauzerlar yoki muhitlar uchun mosligini tekshirish muhim. Brauzer qo'llab-quvvatlashini tekshirish uchun Can I use kabi vositadan foydalanishingiz mumkin. Agar siz eski brauzerlarni qo'llab-quvvatlashingiz kerak bo'lsa, polifilldan foydalanishni o'ylab ko'rishingiz mumkin, ammo polifillar ishlash samaradorligiga ta'sir qilishi mumkinligini unutmang.
Ishlash Samaradorligini Hisobga Olish
BigInt katta butun sonlar bilan ishlashning kuchli usulini taqdim etsa-da, potentsial ishlash samaradorligi oqibatlaridan xabardor bo'lish muhim.
BigIntamallari standartNumberamallaridan sekinroq bo'lishi mumkin.BigIntvaNumbero'rtasida konvertatsiya qilish ham qo'shimcha yuklanishga olib kelishi mumkin.
Shuning uchun, BigIntdan faqat zarur bo'lganda foydalaning va agar siz ko'p sonli BigInt amallarini bajarsangiz, kodingizni ishlash samaradorligi uchun optimallashtiring.
Xulosa
BigInt JavaScript'ga qimmatli qo'shimcha bo'lib, dasturchilarga katta butun sonlar arifmetikasini aniqlik bilan boshqarish imkonini beradi. Uning xususiyatlari, cheklovlari va qo'llanilish holatlarini tushunib, siz BigIntdan kriptografiya, moliyaviy hisob-kitoblar va ilmiy hisoblashlar kabi turli sohalarda mustahkam va aniq ilovalar yaratish uchun foydalanishingiz mumkin. Loyihalaringizda BigIntdan foydalanganda brauzer mosligi va ishlash samaradorligi oqibatlarini hisobga olishni unutmang.
Qo'shimcha O'rganish Uchun
- Mozilla Developer Network (MDN) - BigInt
- V8 Blog - BigInt: JavaScript'da Ixtiyoriy Aniqlikdagi Butun Sonlar
Ushbu qo'llanma JavaScript'dagi BigInt haqida keng qamrovli ma'lumot beradi. Chuqurroq ma'lumot va ilg'or texnikalar uchun bog'langan manbalarni o'rganing.