JavaScript BigInt operacijos: Didelių skaičių matematiniai skaičiavimai

„JavaScript“ istoriškai susidūrė su sunkumais tiksliai atvaizduojant labai didelius sveikuosius skaičius, nes jo „Number“ tipas yra dvigubo tikslumo 64 bitų dvejetainis formatas (IEEE 754). Šis apribojimas tampa problema scenarijuose, reikalaujančiuose didesnio tikslumo nei gali pasiūlyti „Number“ tipas, pavyzdžiui, kriptografijoje, finansiniuose skaičiavimuose ar moksliniuose modeliavimuose. Čia pasirodo BigInt – naujas primityvus duomenų tipas „JavaScript“, skirtas atvaizduoti savavališko ilgio sveikuosius skaičius.

Kas yra BigInt?

BigInt yra įmontuotas objektas, kuris suteikia galimybę atvaizduoti sveikuosius skaičius, didesnius nei 2⁵³ - 1, kuris yra didžiausias saugus sveikasis skaičius, kurį „JavaScript“ „Number“ tipas gali tiksliai atvaizduoti. Be BigInt, atliekant skaičiavimus su skaičiais, viršijančiais šią ribą, gali atsirasti tikslumo praradimas ir neteisingi rezultatai. BigInt išsprendžia šią problemą leisdamas dirbti su savavališkai dideliais sveikaisiais skaičiais neprarandant tikslumo.

BigInt kūrimas

BigInt galite sukurti dviem būdais:

• Pridedant n sveikojo skaičiaus literalo gale.
• Iškviestant BigInt() konstruktorių.

Štai keletas pavyzdžių:

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

Atkreipkite dėmesį, kad BigInt galite sukurti iš skaičiaus, skaičių atvaizduojančios eilutės arba tiesiogiai kaip BigInt literalą. Bandant sukurti BigInt iš slankiojo kablelio skaičiaus, bus gauta RangeError.

Pagrindinės BigInt operacijos

BigInt palaiko daugumą standartinių aritmetinių operatorių, įskaitant sudėtį, atimtį, daugybą, dalybą ir modulį.

Aritmetiniai operatoriai

Štai kaip naudoti pagrindinius aritmetinius operatorius su BigInt:

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

console.log(a + b); // Output: 15n (Sudėtis)
console.log(a - b); // Output: 5n (Atimtis)
console.log(a * b); // Output: 50n (Daugyba)
console.log(a / b); // Output: 2n (Dalyba – nukerta link nulio)
console.log(a % b); // Output: 0n (Modulis)
console.log(a ** b); // Output: 100000n (Laipsnis)

Svarbi pastaba: Negalite maišyti BigInt su Number tipu aritmetinėse operacijose. Tai padarius, atsiras TypeError. Prieš atlikdami operaciją, turite aiškiai konvertuoti Number į BigInt.

const bigInt = 10n;
const number = 5;

// console.log(bigInt + number); // Sukelia TypeError
console.log(bigInt + BigInt(number)); // Išvestis: 15n (Teisingai)

Palyginimo operatoriai

BigInt galima palyginti naudojant standartinius palyginimo operatorius:

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

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

console.log(a == BigInt(10)); // Išvestis: true
console.log(a === BigInt(10)); // Išvestis: true

console.log(a == 10); // Išvestis: true
console.log(a === 10); // Išvestis: false

Nors galite naudoti laisvą lygybę (==) BigInt palyginimui su Number, paprastai rekomenduojama naudoti griežtą lygybę (===) ir aiškiai konvertuoti Number į BigInt, kad būtų aiškiau ir būtų išvengta netikėto tipo keitimo.

Bitiniai operatoriai

BigInt taip pat palaiko bitinius operatorius:

const a = 10n; // 1010 dvejetainiu pavidalu
const b = 3n;  // 0011 dvejetainiu pavidalu

console.log(a & b); // Išvestis: 2n (Bitinis IR)
console.log(a | b); // Išvestis: 11n (Bitinis ARBA)
console.log(a ^ b); // Išvestis: 9n (Bitinis XOR)
console.log(~a);  // Išvestis: -11n (Bitinis NE – dvejetainis papildas)
console.log(a << b); // Išvestis: 80n (Poslinkis į kairę)
console.log(a >> b); // Išvestis: 1n (Poslinkis į dešinę)
console.log(a >>> b); // Sukelia TypeError (Nepasirašytas poslinkis į dešinę nepalaikomas BigInt)

Atkreipkite dėmesį, kad nepasirašytas poslinkio į dešinę operatorius (>>>) nepalaikomas BigInt tipui, nes BigInt visada yra pasirašyti.

Pažangios BigInt technikos

Darbas su bibliotekomis

Nors BigInt suteikia pagrindinius didelių skaičių aritmetikos elementus, specializuotų bibliotekų naudojimas gali žymiai pagerinti našumą ir suteikti papildomų funkcijų sudėtingesnėms operacijoms. Štai kelios žinomos bibliotekos:

• jsbn: Greitas, nešiojamas didelių skaičių matematikos įgyvendinimas gryname „JavaScript“.
• BigInteger.js: Kita populiari biblioteka, siūlanti platų aritmetinių ir bitinių operacijų rinkinį su savavališko ilgio sveikaisiais skaičiais.
• elliptic: Specialiai sukurta elipsinių kreivių kriptografijai, kuri labai priklauso nuo BigInt aritmetikos.

Šios bibliotekos dažnai teikia optimizuotus algoritmus ir specializuotas funkcijas, kurios gali būti lemiamos našumui jautrioms programoms.

Našumo aspektai

Nors BigInt leidžia pasiekti savavališką tikslumą, būtina žinoti apie jo našumo pasekmes. BigInt operacijos paprastai yra lėtesnės nei Number operacijos, nes joms reikia daugiau atminties ir skaičiavimo resursų. Todėl labai svarbu naudoti BigInt tik tada, kai būtina, ir optimizuoti kodą našumui.

Štai keletas patarimų, kaip optimizuoti BigInt našumą:

• Venkite nereikalingų konversijų: Sumažinkite konversijų tarp Numbers ir BigInt skaičių.
• Naudokite efektyvius algoritmus: Pasirinkite algoritmus, optimizuotus didelių skaičių aritmetikai. Bibliotekos, tokios kaip jsbn ir BigInteger.js, dažnai teikia labai optimizuotus įgyvendinimus.
• Profiluokite savo kodą: Naudokite „JavaScript“ profiliavimo įrankius, kad nustatytumėte našumo kliūtis ir atitinkamai optimizuotumėte kodą.

Tipų saugumas

„TypeScript“ teikia puikų BigInt palaikymą, leidžiantį užtikrinti tipų saugumą ir išvengti klaidų, susijusių su BigInt ir Number maišymu. Galite aiškiai deklaruoti kintamuosius kaip BigInt, kad užtikrintumėte, jog juose bus tik BigInt reikšmės.

let bigIntValue: bigint = 12345678901234567890n;

// bigIntValue = 5; // TypeScript išmes klaidą, nes bandote priskirti skaičių bigint tipui.

console.log(bigIntValue);

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

console.log(addBigInts(10n, 20n)); // Išvestis: 30n
// console.log(addBigInts(10, 20)); // TypeScript išmes klaidą

Naudodami „TypeScript“ tipų sistemą, galite anksti aptikti galimas klaidas kūrimo procese ir pagerinti savo kodo patikimumą.

BigInt pritaikymas realiame pasaulyje

BigInt yra būtini įvairiose srityse, kur tikslus didelių sveikųjų skaičių tvarkymas yra labai svarbus. Panagrinėkime keletą žymių pritaikymų:

Kriptografija

Kriptografija labai priklauso nuo didelių pirminių skaičių ir sudėtingų matematinių operacijų, kurioms reikalingas savavališkas tikslumas. BigInt yra nepakeičiami įgyvendinant kriptografinius algoritmus, tokius kaip RSA, ECC (elipsinių kreivių kriptografija) ir Diffie-Hellman rakto mainai.

Pavyzdys: RSA šifravimas

RSA apima didelių pirminių skaičių generavimą ir moduliarinį laipsnių kėlimą dideliais sveikaisiais skaičiais. BigInt naudojami šiems pirminiams skaičiams atvaizduoti ir atlikti reikiamus skaičiavimus neprarandant tikslumo. RSA saugumas priklauso nuo didelių skaičių faktorizavimo sudėtingumo, todėl BigInt yra labai svarbūs jo įgyvendinimui.

Finansiniai skaičiavimai

Finansiniai skaičiavimai dažnai apima didelių pinigų sumų tvarkymą arba sudėtingų skaičiavimų atlikimą dideliu tikslumu. BigInt gali būti naudojami tiksliai atvaizduoti pinigines vertes ir išvengti apvalinimo klaidų, kurios gali atsirasti naudojant slankiojo kablelio skaičius. Tai ypač svarbu tokiose programose kaip apskaitos sistemos, bankininkystės programinė įranga ir finansinis modeliavimas.

Pavyzdys: Didelės paskolos palūkanų skaičiavimas

Skaičiuojant didelės paskolos palūkanas, net ir nedidelės apvalinimo klaidos laikui bėgant gali kauptis ir sukelti reikšmingų neatitikimų. Naudojant BigInt pagrindinei sumai, palūkanų normai ir kitoms susijusioms vertėms atvaizduoti užtikrinama, kad skaičiavimai būtų tikslūs ir patikimi.

Moksliniai skaičiavimai

Moksliniai modeliavimai ir skaičiavimai dažnai apima labai didelių ar mažų skaičių tvarkymą. BigInt gali būti naudojami tiksliai atvaizduoti šiuos skaičius ir atlikti reikiamus skaičiavimus neprarandant tikslumo. Tai ypač svarbu tokiose srityse kaip astronomija, fizika ir chemija, kur tikslumas yra svarbiausias.

Pavyzdys: Atomų skaičiaus molekulėje apskaičiavimas

Avogadro skaičius (apie 6.022 x 10²³) atspindi atomų skaičių molyje medžiagos. Šis skaičius gerokai viršija saugią „JavaScript“ „Number“ tipo sveikojo skaičiaus ribą. Naudojant BigInt, galite tiksliai atvaizduoti Avogadro skaičių ir atlikti skaičiavimus, susijusius su juo, neprarandant tikslumo.

Didelio tikslumo laiko žymos

Paskirstytose sistemose ar aukšto dažnio prekybos programose tikslios laiko žymos yra būtinos duomenų nuoseklumo palaikymui ir įvykių teisingam išdėstymui. BigInt gali būti naudojami atvaizduoti laiko žymas nanosekundžių ar net pikosekundžių tikslumu, užtikrinant, kad įvykiai būtų tiksliai išdėstyti, net ir scenarijuose su itin dideliu įvykių dažniu.

„Blockchain“ technologija

„Blockchain“ technologija labai priklauso nuo kriptografinių operacijų ir didelių skaičių aritmetikos. BigInt naudojami atvaizduoti operacijų ID, blokų maišas ir kitas kriptografines vertes dideliu tikslumu. Jie taip pat naudojami išmaniuosiuose kontraktuose atlikti sudėtingus skaičiavimus ir vykdyti finansines taisykles, nesiremiant slankiojo kablelio skaičiais.

Pavyzdys: Ethereum išmanieji kontraktai

„Ethereum“ išmanieji kontraktai dažnai apima sudėtingus finansinius skaičiavimus ir skaitmeninio turto valdymą. Naudojant BigInt užtikrinama, kad šie skaičiavimai būtų atliekami tiksliai ir kad turto vertės būtų atvaizduojamos be apvalinimo klaidų.

Naršyklės suderinamumas

BigInt puikiai palaiko modernios naršyklės, įskaitant „Chrome“, „Firefox“, „Safari“ ir „Edge“. Tačiau, kuriant programas, kurioms reikia palaikyti senesnes naršykles, būtina atsižvelgti į naršyklės suderinamumą. Galite naudoti „polyfills“ arba „transpilers“, tokius kaip „Babel“, kad suteiktumėte BigInt palaikymą senesnėms naršyklėms. Daugelis senesnių naršyklių neturi gimtojo BigInt palaikymo, tačiau yra prieinami „polyfills“, kurie prideda funkcionalumo. Atnaujintą lentelę rasite „CanIUse“ svetainėje.

Pavyzdžiui, „Babel“ gali perkompiliuoti jūsų kodą, naudojantį BigInt, į lygiavertį kodą, kuris veikia net ir senesnėse „Javascript“ varikliuose.

Konvertavimas į ir iš kitų tipų

Konvertuojant tarp BigInt ir kitų „JavaScript“ tipų reikalinga aiški konversija. Štai taisyklės:

• Į Number: Naudokite Number(bigIntValue). Būkite atsargūs, nes tai gali sukelti tikslumo praradimą, jei BigInt yra per didelis.
• Į String: Naudokite String(bigIntValue). Tai paprastai yra saugu ir suteikia BigInt eilutės atvaizdavimą.
• Iš Number: Naudokite BigInt(numberValue). Tai rekomenduojama tik sveikiesiems skaičiams. Slankiojo kablelio skaičiai, perduoti BigInt konstruktoriui, išmes RangeError.
• Iš String: Naudokite BigInt(stringValue). Eilutė turi atvaizduoti sveikąjį skaičių, priešingu atveju įvyks SyntaxError.

let bigIntVal = 123456789012345678901234567890n;
let numVal = Number(bigIntVal); // Potencialiai nuostolinga konversija
let strVal = String(bigIntVal); // Saugi konversija į eilutę

console.log(numVal); // Rodo tikslumo praradimą.
console.log(strVal);

let newBigInt = BigInt(100); // Sukuria iš sveikojo skaičiaus Number

console.log(newBigInt);

let newBigIntFromString = BigInt("98765432109876543210"); // iš eilutės

console.log(newBigIntFromString);

// BigInt(3.14); // sukels diapazono klaidą

Spąstai ir aplinkybės

Nors BigInt yra neįtikėtinai naudingi, turėtumėte žinoti apie tam tikrus spąstus:

• Tipų klaidos: Atminkite, kad BigInt negalima tiesiogiai maišyti su Numbers aritmetinėse operacijose.
• Našumas: BigInt operacijos yra lėtesnės nei standartinės Number operacijos.
• Tikslumo praradimas: Labai didelių BigInt konvertavimas į Numbers gali sukelti tikslumo praradimą dėl Number tipo apribojimų.
• Standartinės bibliotekos palaikymo trūkumas: Ne visi standartiniai „JavaScript“ metodai yra tiesiogiai suderinami su BigInt. Gali tekti įdiegti pasirinktines funkcijas arba naudoti bibliotekas, kurios aiškiai palaiko BigInt.
• Operatoriaus pirmenybė: Atkreipkite dėmesį į operatoriaus pirmenybę, kai naudojate bitinius operatorius su BigInt.

Išvada

BigInt yra galingas „JavaScript“ papildymas, leidžiantis kūrėjams dirbti su savavališkai dideliais sveikaisiais skaičiais neprarandant tikslumo. Šis gebėjimas yra būtinas įvairiose srityse, įskaitant kriptografiją, finansinius skaičiavimus, mokslinius skaičiavimus ir „blockchain“ technologiją. Supratę BigInt operacijų pagrindus, našumo aspektus ir realaus pasaulio pritaikymus, kūrėjai gali panaudoti šį duomenų tipą kurdami patikimesnes programas, kurioms reikia tikslaus didelių skaičių tvarkymo. Nors yra tam tikrų našumo ir tipo aspektų, BigInt naudojimo privalumai, kai to reikia, yra žymūs.

„JavaScript“ toliau tobulėjant, BigInt neabejotinai vaidins vis svarbesnį vaidmenį, leidžiantį kūrėjams spręsti sudėtingas problemas, kurioms reikalinga savavališko tikslumo aritmetika. Pasaulis vis labiau priklauso nuo skaičiavimų, o tikslumas yra svarbiausias.

Laikykite šį išsamų vadovą pradiniu tašku, gilinkitės į bibliotekas ir tyrinėkite kūrybinius būdus, kaip pritaikyti BigInt savo projektuose.