JavaScript BigInt Operácie: Matematické výpočty s veľkými číslami

JavaScript historicky zápasil s presným zobrazovaním veľmi veľkých celých čísel kvôli tomu, že jeho typ Number je binárny formát s dvojitou presnosťou (IEEE 754). Toto obmedzenie sa stáva problematickým v scenároch, ktoré vyžadujú presnosť nad rámec toho, čo Number ponúka, ako je kryptografia, finančné výpočty alebo vedecké simulácie. Vstupuje BigInt, nový primitívny dátový typ v jazyku JavaScript, ktorý je navrhnutý na reprezentáciu celých čísel ľubovoľnej dĺžky.

Čo je BigInt?

BigInt je vstavaný objekt, ktorý poskytuje spôsob reprezentácie celých čísel väčších ako 2⁵³ - 1, čo je maximálne bezpečné celé číslo, ktoré typ Number jazyka JavaScript dokáže presne reprezentovať. Bez BigInt môže vykonávanie výpočtov s číslami, ktoré presahujú tento limit, viesť k strate presnosti a nesprávnym výsledkom. BigInt rieši tento problém tým, že vám umožňuje pracovať s ľubovoľne veľkými celými číslami bez straty presnosti.

Vytváranie BigInts

BigInt môžete vytvoriť dvoma spôsobmi:

• Pridaním n na koniec celočíselného literálu.
• Volaním konštruktora BigInt().

Tu je niekoľko príkladov:

const bigIntLiteral = 123456789012345678901234567890n;
const bigIntConstructor = BigInt(123456789012345678901234567890);
const bigIntFromString = BigInt("123456789012345678901234567890");

console.log(bigIntLiteral); // Output: 123456789012345678901234567890n
console.log(bigIntConstructor); // Output: 123456789012345678901234567890n
console.log(bigIntFromString); // Output: 123456789012345678901234567890n

Upozorňujeme, že BigInt môžete vytvoriť z čísla, reťazca reprezentujúceho číslo alebo priamo ako BigInt literál. Pokus o vytvorenie BigInt z čísla s plávajúcou desatinnou čiarkou bude mať za následok RangeError.

Základné operácie BigInt

BigInt podporuje väčšinu štandardných aritmetických operátorov, vrátane sčítania, odčítania, násobenia, delenia a modulu.

Aritmetické operátory

Tu je postup, ako používať základné aritmetické operátory s BigInt:

const a = 10n;
const b = 5n;

console.log(a + b); // Output: 15n (Sčítanie)
console.log(a - b); // Output: 5n (Odčítanie)
console.log(a * b); // Output: 50n (Násobenie)
console.log(a / b); // Output: 2n (Delenie - skracuje smerom k nule)
console.log(a % b); // Output: 0n (Modulo)
console.log(a ** b); // Output: 100000n (Umocňovanie)

Dôležitá poznámka: V aritmetických operáciách nemôžete kombinovať BigInts s Numbers. Ak tak urobíte, výsledkom bude TypeError. Pred vykonaním operácie musíte explicitne konvertovať Number na BigInt.

const bigInt = 10n;
const number = 5;

// console.log(bigInt + number); // Vyvolá TypeError
console.log(bigInt + BigInt(number)); // Output: 15n (Správne)

Operátory porovnania

BigInts je možné porovnávať pomocou štandardných operátorov porovnania:

const a = 10n;
const b = 5n;

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

console.log(a == BigInt(10)); // Output: true
console.log(a === BigInt(10)); // Output: true

console.log(a == 10); // Output: true
console.log(a === 10); // Output: false

Aj keď môžete použiť voľnú rovnosť (==) na porovnanie BigInt s Number, všeobecne sa odporúča použiť striktnú rovnosť (===) a explicitne konvertovať Number na BigInt pre prehľadnosť a aby ste sa vyhli neočakávanej koercii typu.

Bitové operátory

BigInts tiež podporuje bitové operátory:

const a = 10n; // 1010 v binárnom kóde
const b = 3n;  // 0011 v binárnom kóde

console.log(a & b); // Output: 2n (Bitový AND)
console.log(a | b); // Output: 11n (Bitový OR)
console.log(a ^ b); // Output: 9n (Bitový XOR)
console.log(~a);  // Output: -11n (Bitový NOT - dvojkový doplnok)
console.log(a << b); // Output: 80n (Posun vľavo)
console.log(a >> b); // Output: 1n (Posun vpravo)
console.log(a >>> b); // Vyvolá TypeError (Nepodpísaný posun vpravo nie je pre BigInt podporovaný)

Upozorňujeme, že operátor nepodpísaného posunu vpravo (>>>) nie je pre BigInts podporovaný, pretože BigInts sú vždy podpísané.

Pokročilé techniky BigInt

Práca s knižnicami

Zatiaľ čo BigInt poskytuje základné stavebné bloky pre aritmetiku s veľkými číslami, použitie špecializovaných knižníc môže výrazne zvýšiť výkon a poskytnúť ďalšie funkcie pre zložitejšie operácie. Tu je niekoľko pozoruhodných knižníc:

• jsbn: Rýchla, prenosná implementácia matematiky s veľkými číslami v čistom JavaScripte.
• BigInteger.js: Ďalšia populárna knižnica, ktorá ponúka komplexnú sadu aritmetických a bitových operácií s celými číslami ľubovoľnej dĺžky.
• elliptic: Špeciálne navrhnutá pre kryptografiu eliptických kriviek, ktorá sa vo veľkej miere spolieha na aritmetiku BigInt.

Tieto knižnice často poskytujú optimalizované algoritmy a špecializované funkcie, ktoré môžu byť rozhodujúce pre aplikácie citlivé na výkon.

Úvahy o výkone

Zatiaľ čo BigInt umožňuje ľubovoľnú presnosť, je dôležité si uvedomiť jeho dôsledky na výkon. Operácie BigInt sú vo všeobecnosti pomalšie ako operácie Number, pretože vyžadujú viac pamäte a výpočtových zdrojov. Preto je dôležité používať BigInt iba vtedy, keď je to potrebné, a optimalizovať svoj kód pre výkon.

Tu je niekoľko tipov na optimalizáciu výkonu BigInt:

• Vyhnite sa zbytočným konverziám: Minimalizujte počet konverzií medzi Numbers a BigInts.
• Používajte efektívne algoritmy: Vyberte si algoritmy, ktoré sú optimalizované pre aritmetiku s veľkými číslami. Knižnice ako jsbn a BigInteger.js často poskytujú vysoko optimalizované implementácie.
• Profilujte svoj kód: Používajte nástroje na profilovanie JavaScriptu na identifikáciu úzkych miest výkonu a podľa toho optimalizujte svoj kód.

Typová bezpečnosť

TypeScript poskytuje vynikajúcu podporu pre BigInt, čo vám umožňuje vynútiť typovú bezpečnosť a zabrániť chybám súvisiacim s kombinovaním BigInts s Numbers. Premenné môžete explicitne deklarovať ako BigInt, aby ste zaistili, že budú obsahovať iba hodnoty BigInt.

let bigIntValue: bigint = 12345678901234567890n;

// bigIntValue = 5; // TypeScript vyvolá chybu, pretože sa pokúšate priradiť číslo k bigint.

console.log(bigIntValue);

function addBigInts(a: bigint, b: bigint): bigint {
  return a + b;
}

console.log(addBigInts(10n, 20n)); // Output: 30n
// console.log(addBigInts(10, 20)); // TypeScript vyvolá chybu

Využitím typového systému TypeScript môžete zachytiť potenciálne chyby už v ranom štádiu vývoja a zlepšiť spoľahlivosť svojho kódu.

Aplikácie BigInt v reálnom svete

BigInts sú nevyhnutné v rôznych oblastiach, kde je rozhodujúca presná manipulácia s veľkými celými číslami. Preskúmajme niektoré významné aplikácie:

Kryptografia

Kryptografia sa vo veľkej miere spolieha na veľké prvočísla a zložité matematické operácie, ktoré vyžadujú ľubovoľnú presnosť. BigInts sú nevyhnutné na implementáciu kryptografických algoritmov, ako sú RSA, ECC (Elliptic Curve Cryptography) a Diffie-Hellmanova výmena kľúčov.

Príklad: Šifrovanie RSA

RSA zahŕňa generovanie veľkých prvočísel a vykonávanie modulárneho umocňovania s veľkými celými číslami. BigInts sa používajú na reprezentáciu týchto prvočísel a na vykonávanie potrebných výpočtov bez straty presnosti. Bezpečnosť RSA závisí od náročnosti faktorizácie veľkých čísel, vďaka čomu sú BigInts rozhodujúce pre jeho implementáciu.

Finančné výpočty

Finančné výpočty často zahŕňajú manipuláciu s veľkými sumami peňazí alebo vykonávanie zložitých výpočtov s vysokou presnosťou. BigInts možno použiť na presné reprezentovanie peňažných hodnôt a zabránenie chybám zaokrúhľovania, ktoré sa môžu vyskytnúť pri použití čísel s plávajúcou desatinnou čiarkou. To je obzvlášť dôležité v aplikáciách, ako sú účtovné systémy, bankový softvér a finančné modelovanie.

Príklad: Výpočet úroku z veľkého úveru

Pri výpočte úroku z veľkého úveru sa aj malé chyby zaokrúhľovania môžu časom nahromadiť a viesť k značným rozdielom. Použitie BigInts na reprezentáciu istiny, úrokovej sadzby a ďalších relevantných hodnôt zaisťuje, že výpočty sú presné a spoľahlivé.

Vedecké výpočty

Vedecké simulácie a výpočty často zahŕňajú manipuláciu s extrémne veľkými alebo malými číslami. BigInts možno použiť na presné reprezentovanie týchto čísel a vykonávanie potrebných výpočtov bez straty presnosti. To je obzvlášť dôležité v oblastiach, ako je astronómia, fyzika a chémia, kde je presnosť prvoradá.

Príklad: Výpočet počtu atómov v móle

Avogadrovo číslo (približne 6,022 x 10²³) predstavuje počet atómov v móle látky. Toto číslo je ďaleko za bezpečným celočíselným limitom typu Number v jazyku JavaScript. Použitie BigInts vám umožňuje presne reprezentovať Avogadrovo číslo a vykonávať výpočty, ktoré ho zahŕňajú, bez straty presnosti.

Časové pečiatky s vysokou presnosťou

V distribuovaných systémoch alebo vysokofrekvenčných obchodných aplikáciách sú presné časové pečiatky nevyhnutné na udržiavanie konzistencie údajov a správne usporiadanie udalostí. BigInts možno použiť na reprezentáciu časových pečiatok s presnosťou na nanosekundy alebo dokonca pikosekundy, čím sa zabezpečí presné usporiadanie udalostí, a to aj v scenároch s extrémne vysokou frekvenciou udalostí.

Technológia Blockchain

Technológia Blockchain sa vo veľkej miere spolieha na kryptografické operácie a aritmetiku s veľkými číslami. BigInts sa používajú na reprezentáciu ID transakcií, hashov blokov a ďalších kryptografických hodnôt s vysokou presnosťou. Používajú sa aj v inteligentných zmluvách na vykonávanie zložitých výpočtov a presadzovanie finančných pravidiel bez toho, aby sa spoliehali na čísla s plávajúcou desatinnou čiarkou.

Príklad: Inteligentné zmluvy Ethereum

Inteligentné zmluvy Ethereum často zahŕňajú zložité finančné výpočty a správu digitálnych aktív. Použitie BigInts zaisťuje, že tieto výpočty sa vykonávajú presne a že hodnoty aktív sú reprezentované bez chýb zaokrúhľovania.

Kompatibilita prehliadača

BigInt má vynikajúcu podporu prehliadača v moderných prehliadačoch, vrátane Chrome, Firefox, Safari a Edge. Je však dôležité zvážiť kompatibilitu prehliadača pri vývoji aplikácií, ktoré potrebujú podporovať staršie prehliadače. Na poskytnutie podpory BigInt pre staršie prehliadače môžete použiť polyfilly alebo transpillery, ako je Babel. Mnohé staršie prehliadače nemajú natívnu podporu BigInt, ale na pridanie funkcií sú k dispozícii polyfilly. Pozrite si webovú stránku CanIUse, kde nájdete aktualizovaný graf.

Napríklad Babel môže transpilovať váš kód pomocou BigInt na ekvivalentný kód, ktorý funguje aj v starších javascriptových motoroch.

Konverzia do az iných typov

Konverzia medzi BigInt a inými typmi JavaScriptu vyžaduje explicitnú konverziu. Tu sú pravidlá:

• Do Number: Použite Number(bigIntValue). Buďte opatrní, pretože to môže viesť k strate presnosti, ak je BigInt príliš veľký.
• Do String: Použite String(bigIntValue). Toto je vo všeobecnosti bezpečné a poskytuje reťazcovú reprezentáciu BigInt.
• From Number: Použite BigInt(numberValue). Toto sa odporúča iba pre celé čísla. Čísla s plávajúcou desatinnou čiarkou odovzdané konštruktoru BigInt vyvolajú RangeError.
• From String: Použite BigInt(stringValue). Reťazec musí reprezentovať celé číslo, inak dôjde k chybe SyntaxError.

let bigIntVal = 123456789012345678901234567890n;
let numVal = Number(bigIntVal); // Potenciálne stratová konverzia
let strVal = String(bigIntVal); // Bezpečná konverzia na reťazec

console.log(numVal); // Zobrazuje stratu presnosti.
console.log(strVal);

let newBigInt = BigInt(100); // Vytvára sa z celočíselného čísla

console.log(newBigInt);

let newBigIntFromString = BigInt("98765432109876543210"); // z reťazca

console.log(newBigIntFromString);

// BigInt(3.14); // spôsobí chybu rozsahu

Úskalia a úvahy

Aj keď sú BigInts neuveriteľne užitočné, mali by ste si byť vedomí určitých úskalí:

• Chyby typu: Pamätajte, že BigInts sa nedajú priamo kombinovať s Numbers v aritmetických operáciách.
• Výkon: Operácie BigInt sú pomalšie ako štandardné operácie Number.
• Strata presnosti: Konverzia veľmi veľkých BigInts na Numbers môže viesť k strate presnosti kvôli obmedzeniam typu Number.
• Nedostatok podpory štandardnej knižnice: Nie všetky štandardné metódy JavaScriptu sú priamo kompatibilné s BigInts. Možno budete musieť implementovať vlastné funkcie alebo použiť knižnice, ktoré explicitne podporujú BigInts.
• Priorita operátorov: Dávajte pozor na prioritu operátorov pri používaní bitových operátorov s BigInts.

Záver

BigInt je výkonný doplnok do JavaScriptu, ktorý umožňuje vývojárom pracovať s ľubovoľne veľkými celými číslami bez straty presnosti. Táto schopnosť je nevyhnutná v rôznych oblastiach, vrátane kryptografie, finančných výpočtov, vedeckých výpočtov a technológie blockchain. Pochopením základov operácií BigInt, úvah o výkone a aplikácií v reálnom svete môžu vývojári využiť tento dátový typ na vytváranie robustnejších a spoľahlivejších aplikácií, ktoré vyžadujú presnú manipuláciu s veľkými číslami. Aj keď existujú určité úvahy o výkone a type, výhody používania BigInt, keď je to potrebné, sú značné.

Keďže sa JavaScript neustále vyvíja, BigInt bude nepochybne hrať čoraz dôležitejšiu úlohu pri umožňovaní vývojárom riešiť zložité problémy, ktoré vyžadujú aritmetiku s ľubovoľnou presnosťou. Svet sa čoraz viac spolieha na výpočty a presnosť je prvoradá.

Považujte tohto komplexného sprievodcu za východiskový bod, ponorte sa hlbšie do knižníc a preskúmajte kreatívne spôsoby, ako aplikovať BigInt na svoje projekty.