JavaScripti BigInt-aritmeetika: suurte arvude arvutused ja täpsuse haldamine

Vaikimisi kasutab JavaScript numbriliste väärtuste esitamiseks andmetüüpi Number. Kuigi see on paljude kasutusjuhtude jaoks piisav, on Number-tüübil piirangud väga suurte täisarvude täpsel esitamisel selle aluseks oleva topelttäpsusega ujukomaformaadi (IEEE 754) tõttu. See võib põhjustada täpsuse kadu ja ootamatuid tulemusi, kui tegeletakse arvudega, mis ületavad selle maksimaalset turvalist täisarvu (Number.MAX_SAFE_INTEGER), mis on 2⁵³ - 1.

Siin tuleb mängu BigInt, ES2020-s tutvustatud sisseehitatud JavaScripti andmetüüp, mis on spetsiaalselt loodud suvalise pikkusega täisarvude esitamiseks. BigInt võimaldab teil teha aritmeetilisi tehteid eriti suurte arvudega ilma täpsust kaotamata. See avab võimalusi arvutusteks sellistes valdkondades nagu krüptograafia, teadusarvutused ja finantsrakendused, kus täpsus on esmatähtis.

Mis on BigInt?

BigInt on primitiivne andmetüüp, mis esindab täisarve, mis on suuremad kui Number-tüüp suudab täpselt käsitleda. Erinevalt Number-tüübist ei ole BigInt-idel fikseeritud suurust, mis tähendab, et nad võivad kasvada mis tahes täisarvu mahutamiseks, piiratud ainult vaba mäluga.

BigInt-ide loomine

JavaScriptis on kaks peamist viisi BigInt-ide loomiseks:

• n-i lisamine täisarvu literaalile: See on kõige otsem meetod. Lihtsalt lisage järelliide 'n' arvu lõppu. Näiteks: 12345678901234567890n.
• BigInt() konstruktori kasutamine: Saate kasutada BigInt() konstruktorit, et teisendada Number, sõne või teine BigInt BigInt-väärtuseks. Näiteks: BigInt(12345) või BigInt("12345678901234567890"). Pange tähele, et ujukomaarvu teisendamine BigInt-iks kärbib komaosa; see ei ümarda.

Näide:

            
const largeNumberLiteral = 9007199254740991n; // 'n' järelliide kasutamine
const largeNumberConstructor = BigInt(9007199254740991); // BigInt() konstruktori kasutamine
const stringBasedBigInt = BigInt("1234567890123456789012345"); // Sõnest loomine

console.log(largeNumberLiteral); // Väljund: 9007199254740991n
console.log(largeNumberConstructor); // Väljund: 9007199254740991n
console.log(stringBasedBigInt); // Väljund: 1234567890123456789012345n

            

              
                Copy
              
            
          

BigInt-aritmeetika tehted

BigInt-id toetavad standardseid aritmeetilisi tehteid nagu liitmine, lahutamine, korrutamine, jagamine ja astendamine. Siiski on olulisi aspekte, mida meeles pidada:

• Segatüübiline aritmeetika ei ole lubatud: Te ei saa otse teha aritmeetilisi tehteid BigInt-ide ja Number-tüüpide vahel. Enne arvutuste tegemist peate Number-tüübid selgesõnaliselt teisendama BigInt-ideks, kasutades BigInt() konstruktorit. See on disainivalik, et vältida tahtmatut täpsuse kadu.
• Jagamise käitumine: BigInt-ide vaheline jagamine kärbib tulemuse nulli suunas, jättes kõrvale murdosa. Puudub jäägiga jagamise operaatori (%) ekvivalent, mis tagastaks murdosa jäägi.
• Võrdlusoperaatorid: Standardsed võrdlusoperaatorid (==, ===, <, >, <=, >=) töötavad BigInt-ide ja Number-tüüpide vahel. Pange tähele, et == teostab tüübi teisenduse, samas kui === tagastab vale (false), kui võrdlete BigInt-i Number-tüübiga.

Aritmeetiliste tehete näited

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

console.log(a + b); // Väljund: 15n (BigInt + BigInt)
console.log(a - b); // Väljund: 5n (BigInt - BigInt)
console.log(a * b); // Väljund: 50n (BigInt * BigInt)
console.log(a / b); // Väljund: 2n (BigInt / BigInt, kärpimine nulli suunas)
console.log(a ** b); // Väljund: 100000n (BigInt astendamine)

//console.log(a + c); // See viskab TypeError'i: Ei saa segada BigInt-i ja teisi tüüpe, kasutage selgesõnalist teisendamist
console.log(a + BigInt(c)); // Väljund: 12n (BigInt + Number, mis on teisendatud BigInt-iks)
console.log(a > BigInt(c)); // Väljund: true (BigInt võrrelduna Number-tüübiga, mis on teisendatud BigInt-iks)

console.log(10n == 10); // Väljund: true
console.log(10n === 10); // Väljund: false

            

              
                Copy
              
            
          

Jäägiga jagamise operaator (%) ja BigInt-id

Jäägiga jagamise operaator (%) ei tööta otse BigInt-idega. Sarnase tulemuse saavutamiseks võite kasutada järgmist lähenemist:

            
function bigIntModulo(dividend, divisor) {
  return dividend - (divisor * (dividend / divisor));
}

const dividend = 25n;
const divisor = 7n;

console.log(bigIntModulo(dividend, divisor)); // Väljund: 4n

            

              
                Copy
              
            
          

BigInt-i piirangud

Kuigi BigInt pakub olulisi eeliseid, on oluline olla teadlik selle piirangutest:

• Komaarvude esitus puudub: BigInt-id saavad esindada ainult täisarve. Neid ei saa kasutada ujukomaaritmeetikas ega komakohtadega arvude esitamiseks. Suure täpsusega komaarvude arvutamiseks kaaluge teekide nagu decimal.js või big.js kasutamist.
• Segamine Number-tüüpidega: Nagu varem mainitud, ei ole otsesed aritmeetilised tehted BigInt-ide ja Number-tüüpide vahel lubatud. Peate selgesõnaliselt teisendama Number-tüübid BigInt-ideks, mis võib teie koodile keerukust lisada.
• Jõudlus: BigInt-tehted võivad olla aeglasemad kui standardsed Number-tehted, eriti väga suurte arvude puhul. See on tingitud sellest, et BigInt-aritmeetika nõuab keerukamaid algoritme ja mäluhaldust. Kaaluge jõudlusmõjusid, kui kasutate BigInt-i jõudluskriitilistes rakendustes.
• JSON-serialiseerimine: BigInt-väärtusi ei saa otse serialiseerida, kasutades JSON.stringify(). BigInt-i otse serialiseerimise katse tulemuseks on TypeError. Enne serialiseerimist peate BigInt-i teisendama sõneks.

JSON-serialiseerimise lahendus

BigInt-väärtuste serialiseerimiseks JSON-is saate kasutada toJSON meetodit või teisendada need selgesõnaliselt sõnedeks:

            
const bigIntValue = 12345678901234567890n;

// 1. meetod: toJSON meetodi kasutamine
BigInt.prototype.toJSON = function() { return this.toString() };

const obj1 = { value: bigIntValue };
const jsonString1 = JSON.stringify(obj1);
console.log(jsonString1); // Väljund: {"value":"12345678901234567890"}

// 2. meetod: Selgesõnaline teisendamine sõneks
const obj2 = { value: bigIntValue.toString() };
const jsonString2 = JSON.stringify(obj2);
console.log(jsonString2); // Väljund: {"value":"12345678901234567890"}

//Parsimisel tuleb see tagasi BigInt-iks teisendada.
const parsedObj = JSON.parse(jsonString2, (key, value) => {
  if (typeof value === 'string' && /^[0-9]+$/.test(value)) {
    try {
      return BigInt(value);
    } catch (e) {
      return value; // Ei ole BigInt-sõne
    }
  }
  return value;
});

console.log(parsedObj.value); //Väljund: 12345678901234567890n
console.log(typeof parsedObj.value); //Väljund: bigint


            

              
                Copy
              
            
          

BigInt-i reaalsed kasutusjuhud

BigInt-id on väärtuslikud stsenaariumides, kus täpsed arvutused suurte täisarvudega on kriitilise tähtsusega. Siin on mõned silmapaistvad kasutusjuhud:

• Krüptograafia: Krüptograafilised algoritmid hõlmavad sageli arvutusi erakordselt suurte algarvudega. BigInt-id on nende algoritmide täpseks rakendamiseks hädavajalikud. Näideteks on RSA krüpteerimine, Diffie-Hellmani võtmevahetus ja elliptilise kõvera krüptograafia. Näiteks suurte algarvude genereerimine RSA jaoks hõlmab väga suurte arvude algarvulisuse kontrollimist, mis on ülesanne, kus BigInt on ülioluline.
• Finantsrakendused: Suurte rahasummade käsitlemine või keerukate finantsarvutuste tegemine nõuab suurt täpsust ümardamisvigade vältimiseks. BigInt-id võivad tagada rahaliste väärtuste täpse esitamise, eriti süsteemides, mis tegelevad rahvusvaheliste valuutade ja tehingutega. Kujutage ette intressi arvutamist pika perioodi jooksul väga suurel laenul; BigInt suudab säilitada vajaliku täpsuse.
• Teadusarvutused: Teaduslikud simulatsioonid ja arvutused hõlmavad sageli väga suurte või väga väikeste arvudega tegelemist. BigInt-e saab kasutada suurte täisarvude esitamiseks teaduslikes mudelites ja simulatsioonides. Näideteks on faktoriaalide arvutamine, osakeste interaktsioonide simuleerimine ja astronoomiliste nähtuste modelleerimine.
• Plokiahela tehnoloogia: Plokiahela tehingud ja krüptograafilised räsifunktsioonid toetuvad suuresti suurte täisarvude aritmeetikale. BigInt-e kasutatakse tehingusummade, plokkide kõrguste ja muude kriitiliste andmeelementide esitamiseks plokiahela süsteemides. Mõelge Ethereumi plokiahelale, kus gaasihinnad ja tehingutasud väljendatakse sageli väga suurte täisarvudena.
• Suure täpsusega arvutused: Iga rakendus, mis nõuab täpset täisarvu esitust väljaspool Number-tüübi piire, võib BigInt-ist kasu saada. See hõlmab rakendusi sellistes valdkondades nagu arvuteooria, kombinatoorne matemaatika ja mänguarendus.

BigInt ja brauserite ühilduvus

BigInt on JavaScripti suhteliselt uus lisandus, seega on oluline arvestada brauserite ühilduvusega, kui seda oma projektides kasutate. Enamik kaasaegseid brausereid toetab BigInt-i, sealhulgas Chrome, Firefox, Safari ja Edge. Vanemad brauserid aga ei pruugi pakkuda natiivset tuge. Ühilduvust saate kontrollida ressursside abil nagu caniuse.com.

Vanematele brauseritele suunatud projektide puhul võiksite kaaluda polüfülli või transpilaatori nagu Babel kasutamist, et pakkuda BigInt-i tuge. Polüfüll pakub BigInt-i JavaScripti implementatsiooni brauseritele, mis seda natiivselt ei toeta, samas kui transpilaator teisendab teie BigInt-idega koodi samaväärseks koodiks, mis töötab vanemates keskkondades.

BigInt-i kasutamise parimad tavad

BigInt-ide tõhusaks kasutamiseks oma JavaScripti projektides kaaluge järgmisi parimaid tavasid:

• Kasutage BigInt-i ainult siis, kui see on vajalik: Vältige BigInt-i kasutamist, kui te ei pea spetsiaalselt esindama täisarve, mis on suuremad kui Number.MAX_SAFE_INTEGER, või ei vaja suurt täpsust. BigInt-i asjatu kasutamine võib põhjustada jõudluse vähenemist.
• Teisendage Number-tüübid selgesõnaliselt BigInt-ideks: Teisendage Number-tüübid alati selgesõnaliselt BigInt-ideks, kasutades BigInt() konstruktorit enne aritmeetiliste tehete tegemist. See aitab vältida juhuslikke tüübivigu ja tagab, et teie arvutused tehakse õigesti.
• Olge teadlik jagamise käitumisest: Pidage meeles, et BigInt-ide vaheline jagamine kärbib tulemuse nulli suunas. Kui peate käsitlema jääke, kasutage bigIntModulo funktsiooni või sarnast lähenemist.
• Kaaluge jõudlusmõjusid: BigInt-tehted võivad olla aeglasemad kui Number-tehted, eriti väga suurte arvude puhul. Testige oma koodi põhjalikult, et tuvastada potentsiaalsed jõudluse kitsaskohad ja optimeerida oma BigInt-i kasutust.
• Käsitlege JSON-serialiseerimist hoolikalt: Pidage meeles, et BigInt-väärtused tuleb enne JSON-i serialiseerimist teisendada sõnedeks ja JSON-i parsimisel tagasi BigInt-ideks teisendada.
• Kasutage selgeid ja kirjeldavaid muutujate nimesid: BigInt-idega töötades kasutage muutujate nimesid, mis viitavad selgelt, et väärtus on BigInt. See aitab parandada koodi loetavust ja vältida segadust. Näiteks kasutage nimesid nagu largeValueBigInt või userIdBigInt.
• Dokumenteerige oma kood: Lisage oma koodile kommentaare, et selgitada, miks te kasutate BigInt-e ja selgitada kõiki potentsiaalselt segadust tekitavaid aspekte oma BigInt-arvutustes.

Kokkuvõte

JavaScripti BigInt-andmetüüp pakub võimsat lahendust suurte täisarvude täpseks arvutamiseks. Mõistes selle omadusi, piiranguid ja parimaid tavasid, saate BigInt-e tõhusalt kasutada laias valikus rakendustes, alates krüptograafiast ja finantsmodelleerimisest kuni teadusarvutuste ja plokiahela tehnoloogiani. Kuigi on jõudluse ja ühilduvusega seotud kaalutlusi, kaaluvad täpse suurte täisarvude esitamise eelised sageli üles puudused, eriti olukordades, kus täpsus on esmatähtis. Pidage alati meeles, et ootamatute vigade vältimiseks tuleb Number- ja BigInt-tüüpide vahel selgesõnaliselt teisendada ning JSON-serialiseerimist hoolikalt käsitleda. JavaScripti arenedes mängib BigInt kahtlemata üha olulisemat rolli, võimaldades arendajatel enesekindlalt ja täpselt lahendada keerulisi numbrilisi väljakutseid.