JavaScript BigInt: Zvládnutie aritmetiky veľkých celých čísel

JavaScript, hoci je všestranný jazyk, má obmedzenia pri práci s veľmi veľkými celými číslami. Štandardný typ `Number` dokáže presne reprezentovať iba celé čísla do určitej hranice, známej ako `Number.MAX_SAFE_INTEGER`. Za touto hranicou sa výpočty stávajú nepresnými, čo vedie k neočakávaným výsledkom. Tu prichádza na pomoc BigInt. BigInt, ktorý bol predstavený v ECMAScript 2020, je vstavaný objekt, ktorý poskytuje spôsob reprezentácie a manipulácie s celými číslami ľubovoľnej veľkosti, prekračujúci obmedzenia štandardného typu `Number`.

Pochopenie potreby BigInt

Pred BigInt sa vývojári JavaScriptu museli spoliehať na knižnice alebo vlastné implementácie na manipuláciu s výpočtami veľkých celých čísel. Tieto riešenia často prichádzali s výkonnostnou réžiou a zvýšenou zložitosťou. Zavedenie BigInt poskytlo natívny a efektívny spôsob práce s veľkými celými číslami, čím sa otvorili možnosti pre aplikácie v rôznych oblastiach, vrátane:

• Kryptografia: Bezpečné spracovanie veľkých prvočísel je kľúčové pre kryptografické algoritmy.
• Finančné výpočty: Presné vyjadrenie veľkých peňažných hodnôt bez straty presnosti.
• Vedecké výpočty: Vykonávanie zložitých výpočtov zahŕňajúcich extrémne veľké alebo malé čísla.
• Vysoko presné časové pečiatky: Reprezentácia časových pečiatok s presnosťou na nanosekundy.
• Generovanie ID: Vytváranie jedinečných a veľmi veľkých identifikátorov.

Vytváranie hodnôt BigInt

Existujú dva primárne spôsoby vytvárania hodnôt BigInt v jazyku JavaScript:

1. Použitie konštruktora `BigInt()`: Tento konštruktor dokáže konvertovať číslo, reťazec alebo boolovskú hodnotu na BigInt.
2. Použitie prípony `n`: Pridaním `n` k celočíselnému literálu sa vytvorí BigInt.

Príklady:

Použitie konštruktora `BigInt()`:

const bigIntFromNumber = BigInt(12345678901234567890);
const bigIntFromString = BigInt("98765432109876543210");
const bigIntFromBoolean = BigInt(true); // Výsledok je 1n
const bigIntFromFalseBoolean = BigInt(false); // Výsledok je 0n

console.log(bigIntFromNumber); // Výstup: 12345678901234567890n
console.log(bigIntFromString); // Výstup: 98765432109876543210n
console.log(bigIntFromBoolean); // Výstup: 1n
console.log(bigIntFromFalseBoolean); // Výstup: 0n

Použitie prípony `n`:

const bigIntLiteral = 12345678901234567890n;
console.log(bigIntLiteral); // Výstup: 12345678901234567890n

Dôležitá poznámka: Nemôžete priamo miešať hodnoty BigInt a Number v aritmetických operáciách. Pred vykonaním výpočtov ich musíte explicitne konvertovať na rovnaký typ. Pokus o ich priame zmiešanie bude mať za následok chybu `TypeError`.

Aritmetické operácie BigInt

BigInt podporuje väčšinu štandardných aritmetických operátorov, vrátane:

• Sčítanie (`+`)
• Odčítanie (`-`)
• Násobenie (`*`)
• Delenie (`/`)
• Zvyšok (`%`)
• Umocňovanie (`**`)

Príklady:

const a = 12345678901234567890n;
const b = 98765432109876543210n;

const sum = a + b;
const difference = a - b;
const product = a * b;
const quotient = a / 2n; // Poznámka: Delenie skracuje smerom k nule
const remainder = a % 7n;
const power = a ** 3n; // Umocňovanie funguje podľa očakávania

console.log("Súčet:", sum); // Výstup: Súčet: 111111111011111111100n
console.log("Rozdiel:", difference); // Výstup: Rozdiel: -86419753208641975320n
console.log("Produkt:", product); // Výstup: Produkt: 1219326311370217957951669538098765432100n
console.log("Podiel:", quotient); // Výstup: Podiel: 6172839450617283945n
console.log("Zvyšok:", remainder); // Výstup: Zvyšok: 5n
console.log("Mocnina:", power); // Výstup: Mocnina: 1876412810291823000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n

Dôležité upozornenia:

• Delenie: Delenie s hodnotami BigInt skracuje smerom k nule. To znamená, že desatinná časť výsledku sa zahodí. Ak potrebujete presnejšie delenie, zvážte použitie knižníc, ktoré podporujú aritmetiku s ľubovoľnou presnosťou.
• Unárny operátor plus (+): Unárny operátor plus (+) sa nedá použiť s hodnotami BigInt, pretože by to bolo v rozpore s legacy asm.js kódom. Použite funkciu konverzie `Number()` na konverziu BigInt na Number, ak požadujete číselnú reprezentáciu (s vedomím, že môžete stratiť presnosť).
• Bitové operátory: BigInt tiež podporuje bitové operátory ako `&`, `|`, `^`, `~`, `<<` a `>>`. Tieto operátory fungujú podľa očakávania na binárnej reprezentácii hodnôt BigInt.

Operátory porovnávania

Môžete použiť štandardné operátory porovnávania (`==`, `!=`, `<`, `>`, `<=`, `>=`) na porovnanie hodnôt BigInt s inými hodnotami BigInt alebo dokonca s hodnotami Number. Buďte si však vedomí potenciálu pre typovú koerciu.

Príklady:

const a = 10n;
const b = 20n;
const c = 10;

console.log(a == b);   // Výstup: false
console.log(a != b);   // Výstup: true
console.log(a < b);    // Výstup: true
console.log(a > b);    // Výstup: false
console.log(a <= b);   // Výstup: true
console.log(a >= b);   // Výstup: false

console.log(a == c);   // Výstup: true (typová koercia)
console.log(a === c);  // Výstup: false (žiadna typová koercia)

Osvedčený postup: Použite striktnú rovnosť (`===`) a striktnú nerovnosť (`!==`) na zabránenie neočakávanej typovej koercie pri porovnávaní hodnôt BigInt a Number.

Konverzia medzi BigInt a Number

Hoci priame aritmetické operácie medzi BigInt a Number nie sú povolené, môžete konvertovať medzi týmito dvoma typmi. Uvedomte si však potenciálnu stratu presnosti pri konverzii BigInt na Number, ak hodnota BigInt prekročí `Number.MAX_SAFE_INTEGER`.

Príklady:

const bigIntValue = 9007199254740991n; // Number.MAX_SAFE_INTEGER
const numberValue = Number(bigIntValue); // Konverzia BigInt na Number
console.log(numberValue); // Výstup: 9007199254740991

const largerBigIntValue = 9007199254740992n; // Prekračuje Number.MAX_SAFE_INTEGER
const largerNumberValue = Number(largerBigIntValue);
console.log(largerNumberValue); // Výstup: 9007199254740992 (môže byť nepresné)

const numberToBigInt = BigInt(12345); // Konverzia Number na BigInt
console.log(numberToBigInt); // Výstup: 12345n

Prípady použitia a príklady

Kryptografia

Kryptografické algoritmy sa často spoliehajú na veľmi veľké prvočísla pre bezpečnosť. BigInt poskytuje spôsob reprezentácie a manipulácie s týmito číslami efektívne.

// Príklad: Generovanie jednoduchého (nezabezpečeného) páru kľúčov
function generateKeyPair() {
  const p = 281n; // Prvočíslo
  const q = 283n; // Ďalšie prvočíslo
  const n = p * q; // Modul
  const totient = (p - 1n) * (q - 1n); // Eulerova funkcia totient

  // Vyberte e (verejný exponent) tak, aby 1 < e < totient a gcd(e, totient) = 1
  const e = 17n;

  // Vypočítajte d (súkromný exponent) tak, aby (d * e) % totient = 1
  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("Verejný kľúč:", keyPair.publicKey);
console.log("Súkromný kľúč:", keyPair.privateKey);

Poznámka: Toto je zjednodušený príklad len na demonštračné účely. Kryptografia v reálnom svete používa oveľa väčšie prvočísla a sofistikovanejšie algoritmy.

Finančné výpočty

Pri manipulácii s veľkými sumami peňazí, najmä v medzinárodných transakciách, je presnosť kritická. BigInt môže zabrániť zaokrúhľovacím chybám a zabezpečiť presné výpočty.

// Príklad: Výpočet zloženého úroku
function calculateCompoundInterest(principal, rate, time) {
  const principalBigInt = BigInt(principal * 100); // Konvertovať na centy
  const rateBigInt = BigInt(rate * 10000);       // Konvertovať na desaťtisíciny percenta
  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 USD
const rate = 0.05;    // 5% úroková sadzba
const time = 10;     // 10 rokov

const finalAmount = calculateCompoundInterest(principal, rate, time);
console.log("Konečná suma:", finalAmount); // Výstup: Konečná suma: 1628894.6267774413 (približne)

V tomto príklade konvertujeme istinu a sadzbu na hodnoty BigInt, aby sme sa vyhli zaokrúhľovacím chybám počas výpočtu. Výsledok sa potom skonvertuje späť na Number na zobrazenie.

Práca s veľkými ID

V distribuovaných systémoch môže byť generovanie jedinečných ID na viacerých serveroch náročné. Použitie BigInt vám umožňuje vytvárať veľmi veľké ID, pri ktorých je nepravdepodobné, že dôjde ku kolízii.

// Príklad: Generovanie jedinečného ID na základe časovej pečiatky a ID servera
function generateUniqueId(serverId) {
  const timestamp = BigInt(Date.now());
  const serverIdBigInt = BigInt(serverId);
  const random = BigInt(Math.floor(Math.random() * 1000)); // Pridajte trochu náhodnosti

  // Skombinujte hodnoty na vytvorenie jedinečného ID
  const uniqueId = (timestamp << 20n) + (serverIdBigInt << 10n) + random;
  return uniqueId.toString(); // Vráťte ako reťazec pre jednoduchú manipuláciu
}

const serverId = 123; // Príklad ID servera
const id1 = generateUniqueId(serverId);
const id2 = generateUniqueId(serverId);

console.log("Jedinečné ID 1:", id1);
console.log("Jedinečné ID 2:", id2);

BigInt a JSON

Hodnoty BigInt nie sú natívne podporované formátom JSON. Pokus o serializáciu objektu JavaScript obsahujúceho BigInt pomocou `JSON.stringify()` bude mať za následok `TypeError`. Ak chcete manipulovať s hodnotami BigInt pri práci s JSON, máte niekoľko možností:

1. Konvertovať na reťazec: Konvertujte BigInt na reťazec pred serializáciou. Toto je najbežnejší a najpriamejší prístup.
2. Vlastná serializácia/deserializácia: Použite vlastnú funkciu serializácie/deserializácie na manipuláciu s hodnotami BigInt.

Príklady:

Konvertovanie na reťazec:

const data = {
  id: 12345678901234567890n,
  name: "Ukážkové údaje",
};

// Konvertovať BigInt na reťazec pred serializáciou
data.id = data.id.toString();

const jsonData = JSON.stringify(data);
console.log(jsonData); // Výstup: {"id":"12345678901234567890","name":"Ukážkové údaje"}

// Pri deserializácii budete musieť skonvertovať reťazec späť na BigInt
const parsedData = JSON.parse(jsonData, (key, value) => {
  if (key === "id") {
    return BigInt(value);
  }
  return value;
});

console.log(parsedData.id); // Výstup: 12345678901234567890n

Vlastná serializácia/deserializácia (pomocou `replacer` a `reviver`):

const data = {
  id: 12345678901234567890n,
  name: "Example Data",
};

// Custom serialization
const jsonData = JSON.stringify(data, (key, value) => {
  if (typeof value === 'bigint') {
    return value.toString();
  } else {
    return value;
  }
});

console.log(jsonData);

// Custom deserialization
const parsedData = JSON.parse(jsonData, (key, value) => {
    if (typeof value === 'string' && /^[0-9]+$/.test(value)) { //check if it is a number and a string
      try {
        return BigInt(value);
      } catch(e) {
          return value;
      }
    }
    return value;
});

console.log(parsedData.id);

Kompatibilita s prehliadačmi

BigInt je široko podporovaný v moderných prehliadačoch. Je však nevyhnutné skontrolovať kompatibilitu so staršími prehliadačmi alebo prostrediami. Môžete použiť nástroj ako Can I use na overenie podpory prehliadača. Ak potrebujete podporovať staršie prehliadače, môžete zvážiť použitie polyfill, ale uvedomte si, že polyfill môžu ovplyvniť výkon.

Úvahy o výkone

Hoci BigInt poskytuje výkonný spôsob práce s veľkými celými číslami, je dôležité si uvedomiť potenciálne dôsledky na výkon.

• Operácie BigInt môžu byť pomalšie ako štandardné operácie Number.
• Konverzia medzi BigInt a Number môže tiež spôsobiť réžiu.

Preto používajte BigInt len vtedy, keď je to potrebné, a optimalizujte svoj kód pre výkon, ak vykonávate veľký počet operácií BigInt.

Záver

BigInt je cenný doplnok k jazyku JavaScript, ktorý umožňuje vývojárom manipulovať s aritmetikou veľkých celých čísel s presnosťou. Pochopením jeho funkcií, obmedzení a prípadov použitia môžete využiť BigInt na vytváranie robustných a presných aplikácií v rôznych oblastiach, vrátane kryptografie, finančných výpočtov a vedeckých výpočtov. Nezabudnite zvážiť kompatibilitu s prehliadačmi a dôsledky na výkon pri používaní BigInt vo svojich projektoch.

Ďalšie skúmanie

• Mozilla Developer Network (MDN) - BigInt
• V8 Blog - BigInt: Aritmetika s ľubovoľnou presnosťou v jazyku JavaScript

Tento sprievodca poskytuje komplexný prehľad o BigInt v jazyku JavaScript. Preskúmajte prepojené zdroje pre hlbšie informácie a pokročilé techniky.