JavaScript BigInt-aritmetikk: Beregninger med store tall og presisjonshåndtering

JavaScript bruker som standard datatypen Number for å representere numeriske verdier. Selv om dette er tilstrekkelig for mange bruksområder, har Number-typen begrensninger i å representere veldig store heltall nøyaktig på grunn av det underliggende dobbeltpresisjons flyttallsformatet (IEEE 754). Dette kan føre til tap av presisjon og uventede resultater når man håndterer tall som overstiger det maksimale sikre heltallet (Number.MAX_SAFE_INTEGER), som er 2⁵³ - 1.

Her kommer BigInt, en innebygd JavaScript-datatype introdusert i ES2020, designet spesifikt for å representere heltall av vilkårlig lengde. BigInt lar deg utføre aritmetiske operasjoner på ekstremt store tall uten å miste presisjon. Dette åpner for muligheter for beregninger innen felt som kryptografi, vitenskapelig databehandling og finansielle applikasjoner der nøyaktighet er avgjørende.

Hva er BigInt?

BigInt er en primitiv datatype som representerer heltall som er større enn det Number-typen kan håndtere nøyaktig. I motsetning til Number, har ikke BigInts en fast størrelse, noe som betyr at de kan vokse for å romme ethvert heltall, begrenset kun av tilgjengelig minne.

Opprette BigInts

Det er to primære måter å opprette BigInts på i JavaScript:

• Legge til n etter et heltallsliteral: Dette er den enkleste metoden. Bare legg til suffikset 'n' på slutten av et tall. For eksempel: 12345678901234567890n.
• Bruke BigInt()-konstruktøren: Du kan bruke BigInt()-konstruktøren for å konvertere et Number, en streng eller en annen BigInt til en BigInt-verdi. For eksempel: BigInt(12345) eller BigInt("12345678901234567890"). Merk at konvertering av et flyttall til en BigInt vil trunkere desimaldelen; det avrundes ikke.

Eksempel:

            
const largeNumberLiteral = 9007199254740991n; // Bruker 'n'-suffikset
const largeNumberConstructor = BigInt(9007199254740991); // Bruker BigInt()-konstruktøren
const stringBasedBigInt = BigInt("1234567890123456789012345"); // Oppretter fra en streng

console.log(largeNumberLiteral); // Utdata: 9007199254740991n
console.log(largeNumberConstructor); // Utdata: 9007199254740991n
console.log(stringBasedBigInt); // Utdata: 1234567890123456789012345n

            

              
                Copy
              
            
          

Aritmetiske operasjoner med BigInt

BigInts støtter standard aritmetiske operasjoner som addisjon, subtraksjon, multiplikasjon, divisjon og eksponentiering. Det er imidlertid viktige hensyn å ta:

• Blandet type-aritmetikk er ikke tillatt: Du kan ikke utføre aritmetiske operasjoner direkte mellom BigInts og Numbers. Du må eksplisitt konvertere Numbers til BigInts ved å bruke BigInt()-konstruktøren før du utfører beregninger. Dette er et designvalg for å forhindre utilsiktet tap av presisjon.
• Oppførsel ved divisjon: Divisjon mellom BigInts trunkerer mot null og forkaster enhver brøkdel. Det finnes ingen ekvivalent til modulo-operatoren (%) som returnerer en brøkdel som rest.
• Sammenligningsoperatorer: Standard sammenligningsoperatorer (==, ===, <, >, <=, >=) fungerer mellom BigInts og Numbers. Merk at == vil utføre typekonvertering, mens === vil returnere false hvis du sammenligner en BigInt med et Number.

Eksempler på aritmetiske operasjoner

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

console.log(a + b); // Utdata: 15n (BigInt + BigInt)
console.log(a - b); // Utdata: 5n (BigInt - BigInt)
console.log(a * b); // Utdata: 50n (BigInt * BigInt)
console.log(a / b); // Utdata: 2n (BigInt / BigInt, trunkering mot null)
console.log(a ** b); // Utdata: 100000n (BigInt-eksponentiering)

//console.log(a + c); // Dette vil kaste en TypeError: Kan ikke blande BigInt og andre typer, bruk eksplisitte konverteringer
console.log(a + BigInt(c)); // Utdata: 12n (BigInt + Number konvertert til BigInt)
console.log(a > BigInt(c)); // Utdata: true (BigInt sammenlignet med Number konvertert til BigInt)

console.log(10n == 10); // Utdata: true
console.log(10n === 10); // Utdata: false

            

              
                Copy
              
            
          

Modulo-operatoren (%) og BigInts

Modulo-operatoren (%) fungerer ikke direkte med BigInts. For å oppnå et lignende resultat kan du bruke følgende tilnærming:

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

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

console.log(bigIntModulo(dividend, divisor)); // Utdata: 4n

            

              
                Copy
              
            
          

Begrensninger med BigInt

Selv om BigInt tilbyr betydelige fordeler, er det viktig å være klar over begrensningene:

• Ingen desimalrepresentasjon: BigInts kan bare representere hele tall. De kan ikke brukes til flyttallsaritmetikk eller til å representere tall med desimaler. For høypresisjons desimalberegninger, vurder å bruke biblioteker som decimal.js eller big.js.
• Blanding med Numbers: Som nevnt tidligere er direkte aritmetiske operasjoner mellom BigInts og Numbers ikke tillatt. Du må eksplisitt konvertere Numbers til BigInts, noe som kan øke kompleksiteten i koden din.
• Ytelse: BigInt-operasjoner kan være tregere enn standard Number-operasjoner, spesielt for veldig store tall. Dette er fordi BigInt-aritmetikk krever mer komplekse algoritmer og minnehåndtering. Vurder ytelseskonsekvensene når du bruker BigInt i ytelseskritiske applikasjoner.
• JSON-serialisering: BigInt-verdier kan ikke serialiseres direkte ved hjelp av JSON.stringify(). Forsøk på å serialisere en BigInt direkte vil resultere i en TypeError. Du må konvertere BigInt til en streng før serialisering.

Omgåelse for JSON-serialisering

For å serialisere BigInt-verdier i JSON kan du bruke toJSON-metoden eller eksplisitt konvertere dem til strenger:

            
const bigIntValue = 12345678901234567890n;

// Metode 1: Bruke toJSON-metoden
BigInt.prototype.toJSON = function() { return this.toString() };

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

// Metode 2: Eksplisitt konvertere til streng
const obj2 = { value: bigIntValue.toString() };
const jsonString2 = JSON.stringify(obj2);
console.log(jsonString2); // Utdata: {"value":"12345678901234567890"}

//Ved parsing må du konvertere tilbake til BigInt.
const parsedObj = JSON.parse(jsonString2, (key, value) => {
  if (typeof value === 'string' && /^[0-9]+$/.test(value)) {
    try {
      return BigInt(value);
    } catch (e) {
      return value; // Ikke en BigInt-streng
    }
  }
  return value;
});

console.log(parsedObj.value); //Utdata: 12345678901234567890n
console.log(typeof parsedObj.value); //Utdata: bigint


            

              
                Copy
              
            
          

Reelle bruksområder for BigInt

BigInts er verdifulle i scenarioer der presise beregninger med store heltall er avgjørende. Her er noen fremtredende bruksområder:

• Kryptografi: Kryptografiske algoritmer involverer ofte beregninger med ekstremt store primtall. BigInts er essensielle for å implementere disse algoritmene nøyaktig. Eksempler inkluderer RSA-kryptering, Diffie-Hellman nøkkelutveksling og elliptisk kurve-kryptografi. For eksempel, å generere store primtall for RSA innebærer å sjekke primaliteten til veldig store tall, en oppgave der BigInt er avgjørende.
• Finansielle applikasjoner: Håndtering av store pengesummer eller utføring av komplekse finansielle beregninger krever høy presisjon for å unngå avrundingsfeil. BigInts kan sikre nøyaktig representasjon av pengeverdier, spesielt i systemer som håndterer internasjonale valutaer og transaksjoner. Tenk deg å beregne renter over en lang periode på et veldig stort lån; BigInt kan opprettholde den nødvendige presisjonen.
• Vitenskapelig databehandling: Vitenskapelige simuleringer og beregninger involverer ofte håndtering av veldig store eller veldig små tall. BigInts kan brukes til å representere store heltallsverdier i vitenskapelige modeller og simuleringer. Eksempler inkluderer beregning av fakulteter, simulering av partikkelinteraksjoner og modellering av astronomiske fenomener.
• Blokkjede-teknologi: Blokkjede-transaksjoner og kryptografiske hash-funksjoner er sterkt avhengige av aritmetikk med store heltall. BigInts brukes til å representere transaksjonsbeløp, blokkhøyder og andre kritiske dataelementer i blokkjedesystemer. Vurder Ethereum-blokkjeden, der gasspriser og transaksjonsgebyrer ofte uttrykkes som veldig store heltall.
• Høypresisjonsberegninger: Enhver applikasjon som krever eksakt heltallsrepresentasjon utover grensene for Number-typen kan dra nytte av BigInt. Dette inkluderer applikasjoner innen områder som tallteori, kombinatorisk matematikk og spillutvikling.

BigInt og nettleserkompatibilitet

BigInt er et relativt nytt tillegg til JavaScript, så det er viktig å vurdere nettleserkompatibilitet når du bruker det i prosjektene dine. De fleste moderne nettlesere støtter BigInt, inkludert Chrome, Firefox, Safari og Edge. Eldre nettlesere kan imidlertid mangle innebygd støtte. Du kan sjekke kompatibilitet ved hjelp av ressurser som caniuse.com.

For prosjekter rettet mot eldre nettlesere, kan du vurdere å bruke en polyfill eller en transpiler som Babel for å gi BigInt-støtte. En polyfill gir en JavaScript-implementering av BigInt for nettlesere som ikke støtter det innebygd, mens en transpiler konverterer koden din med BigInts til ekvivalent kode som fungerer i eldre miljøer.

Beste praksis for bruk av BigInt

For å bruke BigInts effektivt i dine JavaScript-prosjekter, bør du vurdere følgende beste praksis:

• Bruk BigInt kun når det er nødvendig: Unngå å bruke BigInt med mindre du spesifikt trenger å representere heltall som er større enn Number.MAX_SAFE_INTEGER eller krever høy presisjon. Unødvendig bruk av BigInt kan føre til redusert ytelse.
• Konverter Numbers eksplisitt til BigInts: Konverter alltid Numbers eksplisitt til BigInts ved å bruke BigInt()-konstruktøren før du utfører aritmetiske operasjoner. Dette bidrar til å forhindre utilsiktede typefeil og sikrer at beregningene dine utføres korrekt.
• Vær oppmerksom på oppførselen ved divisjon: Husk at divisjon mellom BigInts trunkerer mot null. Hvis du trenger å håndtere rester, bruk bigIntModulo-funksjonen eller en lignende tilnærming.
• Vurder ytelseskonsekvensene: BigInt-operasjoner kan være tregere enn Number-operasjoner, spesielt for veldig store tall. Test koden din grundig for å identifisere potensielle ytelsesflaskehalser og optimaliser din bruk av BigInt.
• Håndter JSON-serialisering forsiktig: Husk å konvertere BigInt-verdier til strenger før du serialiserer dem til JSON, og konverter dem tilbake til BigInt når du parser JSON-dataene.
• Bruk tydelige og beskrivende variabelnavn: Når du arbeider med BigInts, bruk variabelnavn som tydelig indikerer at verdien er en BigInt. Dette kan bidra til å forbedre lesbarheten i koden og forhindre forvirring. Bruk for eksempel navn som largeValueBigInt eller userIdBigInt.
• Dokumenter koden din: Legg til kommentarer i koden din for å forklare hvorfor du bruker BigInts og for å klargjøre eventuelle potensielt forvirrende aspekter ved dine BigInt-beregninger.

Konklusjon

JavaScripts BigInt-datatype gir en kraftig løsning for håndtering av beregninger med store heltall med presisjon. Ved å forstå dens funksjoner, begrensninger og beste praksis, kan du effektivt utnytte BigInts i et bredt spekter av applikasjoner, fra kryptografi og finansiell modellering til vitenskapelig databehandling og blokkjede-teknologi. Selv om det er hensyn å ta med tanke på ytelse og kompatibilitet, veier fordelene med nøyaktig representasjon av store heltall ofte opp for ulempene, spesielt i situasjoner der presisjon er avgjørende. Husk alltid å konvertere eksplisitt mellom Number- og BigInt-typer og håndtere JSON-serialisering forsiktig for å unngå uventede feil. Ettersom JavaScript fortsetter å utvikle seg, vil BigInt utvilsomt spille en stadig viktigere rolle i å gjøre det mulig for utviklere å takle komplekse numeriske utfordringer med selvtillit og nøyaktighet.