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 BigInt ga o'zgartira oladi.
`n` qo'shimchasidan foydalanish: Butun sonli literalga `n` qo'shimchasini qo'shish BigInt yaratadi.

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: BigInt qiymatlari 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 (+) BigInt qiymatlari 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: BigInt shuningdek `&`, `|`, `^`, `~`, `<<`, va `>>` kabi bitwise operatorlarni ham qo'llab-quvvatlaydi. Bu operatorlar BigInt qiymatlarining 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: BigInt qiymatlarini 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.

BigInt amallari standart Number amallaridan sekinroq bo'lishi mumkin.
BigInt va Number o'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

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.