JavaScript BigInt: Zvládnutí aritmetiky s velkými celými čísly

JavaScript, ačkoliv je všestranný jazyk, má svá omezení při práci s velmi velkými celými čísly. Standardní typ `Number` může přesně reprezentovat celá čísla pouze do určitého limitu, známého jako `Number.MAX_SAFE_INTEGER`. Za tímto limitem se výpočty stávají nepřesnými, což vede k neočekávaným výsledkům. Právě zde přichází na pomoc BigInt. BigInt, představený v ECMAScript 2020, je vestavěný objekt, který poskytuje způsob, jak reprezentovat a manipulovat s celými čísly libovolné velikosti, čímž překonává omezení standardního typu `Number`.

Pochopení potřeby BigInt

Před zavedením BigInt se vývojáři v JavaScriptu museli spoléhat na knihovny nebo vlastní implementace pro zpracování výpočtů s velkými celými čísly. Tato řešení často přinášela výkonnostní zátěž a zvýšenou složitost. Zavedení BigInt poskytlo nativní a efektivní způsob práce s velkými celými čísly, což otevřelo možnosti pro aplikace v různých oblastech, včetně:

Kryptografie: Bezpečné zpracování velkých prvočísel je klíčové pro kryptografické algoritmy.
Finanční výpočty: Přesná reprezentace velkých peněžních hodnot bez ztráty přesnosti.
Vědecké výpočty: Provádění složitých výpočtů zahrnujících extrémně velká nebo malá čísla.
Vysoko-přesná časová razítka: Reprezentace časových razítek s nanosekundovou přesností.
Generování ID: Vytváření unikátních a velmi velkých identifikátorů.

Vytváření hodnot BigInt

Existují dva hlavní způsoby, jak vytvořit hodnoty BigInt v JavaScriptu:

Použitím konstruktoru `BigInt()`: Tento konstruktor může převést číslo, řetězec nebo booleovskou hodnotu na BigInt.
Použitím přípony `n`: Připojení `n` k celočíselnému literálu vytvoří BigInt.

Příklady:

Použití konstruktoru `BigInt()`:


const bigIntFromNumber = BigInt(12345678901234567890);
const bigIntFromString = BigInt("98765432109876543210");
const bigIntFromBoolean = BigInt(true); // Výsledkem je 1n
const bigIntFromFalseBoolean = BigInt(false); // Výsledkem 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žití přípony `n`:


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

Důležitá poznámka: Nelze přímo míchat hodnoty BigInt a Number v aritmetických operacích. Před provedením výpočtů je nutné je explicitně převést na stejný typ. Pokus o jejich přímé smíchání povede k chybě `TypeError`.

Aritmetické operace s BigInt

BigInt podporuje většinu standardních aritmetických operátorů, včetně:

Sčítání (`+`)
Odčítání (`-`)
Násobení (`*`)
Dělení (`/`)
Zbytek po dělení (`%`)
Mocnění (`**`)

Pří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: Dělení zaokrouhluje směrem k nule
const remainder = a % 7n;
const power = a ** 3n; // Mocnění funguje dle očekávání

console.log("Součet:", sum); // Výstup: Součet: 111111111011111111100n
console.log("Rozdíl:", difference); // Výstup: Rozdíl: -86419753208641975320n
console.log("Součin:", product); // Výstup: Součin: 1219326311370217957951669538098765432100n
console.log("Podíl:", quotient); // Výstup: Podíl: 6172839450617283945n
console.log("Zbytek:", remainder); // Výstup: Zbytek: 5n
console.log("Mocnina:", power); // Výstup: Mocnina: 187641281029182300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n

Důležitá upozornění:

Dělení: Dělení s hodnotami BigInt zaokrouhluje směrem k nule. To znamená, že desetinná část výsledku je zahozená. Pokud potřebujete přesnější dělení, zvažte použití knihoven, které podporují aritmetiku s libovolnou přesností.
Unární operátor plus (+): Unární operátor plus (+) nelze použít s hodnotami BigInt, protože by to bylo v konfliktu se starším kódem asm.js. Pro převod BigInt na Number použijte konverzní funkci `Number()`, pokud požadujete číselnou reprezentaci (s vědomím, že můžete ztratit přesnost).
Bitové operátory: BigInt také podporuje bitové operátory jako `&`, `|`, `^`, `~`, `<<` a `>>`. Tyto operátory fungují dle očekávání na binární reprezentaci hodnot BigInt.

Srovnávací operátory

Můžete používat standardní srovnávací operátory (`==`, `!=`, `<`, `>`, `<=`, `>=`) k porovnávání hodnot BigInt s jinými hodnotami BigInt nebo dokonce s hodnotami Number. Buďte si však vědomi potenciálu pro typovou koerci.

Pří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 (typická koerce)
console.log(a === c);  // Výstup: false (bez typové koerce)

Doporučený postup: Používejte striktní rovnost (`===`) a striktní nerovnost (`!==`), abyste se vyhnuli neočekávané typové koerci při porovnávání hodnot BigInt a Number.

Převod mezi BigInt a Number

Ačkoliv přímé aritmetické operace mezi BigInt a Number nejsou povoleny, můžete mezi těmito dvěma typy převádět. Buďte si však vědomi možné ztráty přesnosti při převodu BigInt na Number, pokud hodnota BigInt přesahuje `Number.MAX_SAFE_INTEGER`.

Příklady:


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

const largerBigIntValue = 9007199254740992n; // Přesahuje Number.MAX_SAFE_INTEGER
const largerNumberValue = Number(largerBigIntValue);
console.log(largerNumberValue); // Výstup: 9007199254740992 (může být nepřesné)

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

Případy použití a příklady

Kryptografie

Kryptografické algoritmy se často spoléhají na velmi velká prvočísla pro zajištění bezpečnosti. BigInt poskytuje způsob, jak efektivně reprezentovat a manipulovat s těmito čísly.


// Příklad: Generování jednoduchého (nezabezpečeného) páru klíčů
function generateKeyPair() {
  const p = 281n; // Prvočíslo
  const q = 283n; // Další prvočíslo
  const n = p * q; // Modul
  const totient = (p - 1n) * (q - 1n); // Eulerova funkce totient

  // Zvolte e (veřejný exponent) tak, aby 1 < e < totient a gcd(e, totient) = 1
  const e = 17n;

  // Vypočítejte d (soukromý 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("Veřejný klíč:", keyPair.publicKey);
console.log("Soukromý klíč:", keyPair.privateKey);

Poznámka: Toto je zjednodušený příklad pouze pro demonstrační účely. Reálná kryptografie používá mnohem větší prvočísla a sofistikovanější algoritmy.

Finanční výpočty

Při práci s velkými částkami peněz, zejména v mezinárodních transakcích, je přesnost klíčová. BigInt může zabránit chybám zaokrouhlování a zajistit přesné výpočty.


// Příklad: Výpočet složeného úroku
function calculateCompoundInterest(principal, rate, time) {
  const principalBigInt = BigInt(principal * 100); // Převod na centy
  const rateBigInt = BigInt(rate * 10000);       // Převod na desetitisíciny procenta
  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% úroková sazba
const time = 10;     // 10 let

const finalAmount = calculateCompoundInterest(principal, rate, time);
console.log("Konečná částka:", finalAmount); // Výstup: Konečná částka: 1628894.6267774413 (přibližně)

V tomto příkladu převádíme jistinu a úrokovou sazbu na hodnoty BigInt, abychom se vyhnuli chybám zaokrouhlování během výpočtu. Výsledek je poté převeden zpět na Number pro zobrazení.

Práce s velkými ID

V distribuovaných systémech může být generování unikátních ID napříč několika servery náročné. Použití BigInt umožňuje vytvářet velmi velká ID, u kterých je nepravděpodobné, že dojde ke kolizi.


// Příklad: Generování unikátního ID na základě časového razítka a ID serveru
function generateUniqueId(serverId) {
  const timestamp = BigInt(Date.now());
  const serverIdBigInt = BigInt(serverId);
  const random = BigInt(Math.floor(Math.random() * 1000)); // Přidání trochy náhodnosti

  // Spojení hodnot pro vytvoření unikátního ID
  const uniqueId = (timestamp << 20n) + (serverIdBigInt << 10n) + random;
  return uniqueId.toString(); // Návrat jako řetězec pro snadnou manipulaci
}

const serverId = 123; // Příklad ID serveru
const id1 = generateUniqueId(serverId);
const id2 = generateUniqueId(serverId);

console.log("Unikátní ID 1:", id1);
console.log("Unikátní ID 2:", id2);

BigInt a JSON

Hodnoty BigInt nejsou nativně podporovány formátem JSON. Pokus o serializaci objektu JavaScript obsahujícího BigInt pomocí `JSON.stringify()` povede k chybě `TypeError`. Pro práci s hodnotami BigInt při použití JSON máte několik možností:

Převod na řetězec: Převeďte BigInt na řetězec před serializací. Toto je nejběžnější a nejpřímočařejší přístup.
Vlastní serializace/deserializace: Použijte vlastní funkci pro serializaci/deserializaci pro zpracování hodnot BigInt.

Příklady:

Převod na řetězec:


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

// Převod BigInt na řetězec před serializací
data.id = data.id.toString();

const jsonData = JSON.stringify(data);
console.log(jsonData); // Výstup: {"id":"12345678901234567890","name":"Example Data"}

// Při deserializaci budete muset převést řetězec zpět 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í serializace/deserializace (použitím `replacer` a `reviver`):


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

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

console.log(jsonData);

// Vlastní deserializace
const parsedData = JSON.parse(jsonData, (key, value) => {
    if (typeof value === 'string' && /^[0-9]+$/.test(value)) { // zkontrolujte, zda je to číslo a řetězec
      try {
        return BigInt(value);
      } catch(e) {
          return value;
      }
    }
    return value;
});

console.log(parsedData.id);

Kompatibilita s prohlížeči

BigInt je široce podporován v moderních prohlížečích. Je však nezbytné zkontrolovat kompatibilitu pro starší prohlížeče nebo prostředí. Můžete použít nástroj jako Can I use k ověření podpory v prohlížečích. Pokud potřebujete podporovat starší prohlížeče, můžete zvážit použití polyfillu, ale buďte si vědomi, že polyfilly mohou ovlivnit výkon.

Výkonnostní aspekty

Ačkoliv BigInt poskytuje mocný způsob práce s velkými celými čísly, je důležité si být vědom možných dopadů na výkon.

Operace s BigInt mohou být pomalejší než standardní operace s Number.
Převod mezi BigInt a Number může také způsobit dodatečnou zátěž.

Proto používejte BigInt pouze v nezbytných případech a optimalizujte svůj kód pro výkon, pokud provádíte velké množství operací s BigInt.

Závěr

BigInt je cenným doplňkem JavaScriptu, který umožňuje vývojářům zpracovávat aritmetiku s velkými celými čísly s přesností. Porozuměním jeho vlastnostem, omezením a případům použití můžete využít BigInt k vytváření robustních a přesných aplikací v různých oblastech, včetně kryptografie, finančních výpočtů a vědeckého počítání. Nezapomeňte při používání BigInt ve svých projektech zvážit kompatibilitu s prohlížeči a dopady na výkon.

Další zdroje

Tento průvodce poskytuje komplexní přehled BigInt v JavaScriptu. Prozkoumejte uvedené zdroje pro podrobnější informace a pokročilé techniky.