JavaScript BigInt: En omfattende guide til beregning af store tal

I mange år stod JavaScript-udviklere over for en stille, men betydelig begrænsning: sprogets indbyggede evne til at håndtere tal. Selvom JavaScripts Number-type er perfekt egnet til hverdagsberegninger, ville den vakle, når den blev konfronteret med de virkelig massive heltal, der kræves inden for områder som kryptografi, videnskabelig databehandling og moderne datasystemer. Dette førte til en verden af workarounds, tredjepartsbiblioteker og subtile, svært debugbare præcisionsfejl.

Den æra er forbi. Introduktionen af BigInt som en indbygget JavaScript-primitivtype har revolutioneret, hvordan vi arbejder med store tal. Det giver en robust, ergonomisk og effektiv måde at udføre vilkårlig præcisions heltal aritmetik direkte i sproget.

Denne omfattende guide er til udviklere over hele kloden. Vi vil dykke dybt ned i "hvorfor, hvad og hvordan" af BigInt. Uanset om du bygger en finansiel applikation, interagerer med en blockchain eller blot forsøger at forstå, hvorfor dit store unikke ID fra en API opfører sig mærkeligt, vil denne artikel udstyre dig med viden til at mestre BigInt.

The Problem: The Boundaries of JavaScript's Number Type

Før vi kan værdsætte løsningen, skal vi fuldt ud forstå problemet. JavaScript har kun haft én taltype i det meste af sin historie: Number-typen. Under motorhjelmen er den repræsenteret som et IEEE 754 dobbeltpræcisions 64-bit flydende kommatal. Dette format er fremragende til at repræsentere en bred vifte af værdier, inklusive decimaler, men det har en kritisk begrænsning, når det kommer til heltal.

Meet MAX_SAFE_INTEGER

På grund af dens flydende kommarepræsentation er der en grænse for størrelsen af et heltal, der kan repræsenteres med perfekt præcision. Denne grænse er eksponeret via en konstant: Number.MAX_SAFE_INTEGER.

Dens værdi er 2⁵³ - 1, hvilket er 9.007.199.254.740.991. Lad os kalde det ni kvadrillioner for kort.

Ethvert heltal inden for området -Number.MAX_SAFE_INTEGER til +Number.MAX_SAFE_INTEGER betragtes som et "sikkert heltal". Det betyder, at det kan repræsenteres præcist og sammenlignes korrekt. Men hvad sker der, når vi træder uden for dette område?

Lad os se det i aktion:

            const maxSafe = Number.MAX_SAFE_INTEGER;
console.log(maxSafe);        // 9007199254740991

// Lad os lægge 1 til det
console.log(maxSafe + 1);    // 9007199254740992 - Dette ser korrekt ud

// Lad os tilføje endnu 1
console.log(maxSafe + 2);    // 9007199254740992 - Uh oh. Forkert resultat.

// Det bliver værre
console.log(maxSafe + 3);    // 9007199254740994 - Vent, hvad?
console.log(maxSafe + 4);    // 9007199254740996 - Den springer tal over!

// Kontrol af lighed mislykkes også
console.log(maxSafe + 1 === maxSafe + 2); // true - Dette er matematisk forkert!
            

              
                Copy
              
            
          

Som du kan se, kan JavaScript ikke længere garantere præcisionen af vores beregninger, når vi overskrider Number.MAX_SAFE_INTEGER. Talrepræsentationen begynder at have huller, hvilket fører til afrundingsfejl og forkerte resultater. Dette er et mareridt for applikationer, der kræver nøjagtighed med store heltal.

The Old Workarounds

I årevis stolede det globale udviklerfællesskab på eksterne biblioteker for at løse dette problem. Biblioteker som bignumber.js, decimal.js og long.js blev standardværktøjer. De fungerede ved at repræsentere store tal som strenge eller arrays af cifre og implementere aritmetiske operationer i software.

Selvom disse biblioteker var effektive, kom de med kompromiser:

• Performance Overhead: Operationer var betydeligt langsommere end oprindelige talberegninger.
• Bundle Size: De tilføjede vægt til applikationsbundter, hvilket er en bekymring for webperformance.
• Different Syntax: Udviklere var nødt til at bruge objektmetoder (f.eks. a.add(b)) i stedet for standard aritmetiske operatorer (a + b), hvilket gjorde koden mindre intuitiv.

Introducing BigInt: The Native Solution

BigInt blev introduceret i ES2020 for at løse dette problem indbygget. En BigInt er en ny primitiv type i JavaScript, der giver en måde at repræsentere hele tal, der er større end 2⁵³ - 1.

Nøglefunktionen ved BigInt er, at dens størrelse ikke er fast. Den kan repræsentere vilkårligt store heltal, kun begrænset af den tilgængelige hukommelse i værtssystemet. Dette eliminerer fuldstændigt de præcisionsproblemer, vi så med Number-typen.

How to Create a BigInt

Der er to primære måder at oprette en BigInt på:

1. Tilføjelse af `n` til et heltalsliteral: Dette er den enkleste og mest almindelige metode.
2. Brug af `BigInt()` konstruktørfunktionen: Dette er nyttigt, når du konverterer en værdi fra en anden type, som f.eks. en streng eller et tal.

Her er, hvordan de ser ud i kode:

            // 1. Brug af 'n'-suffikset
const myFirstBigInt = 900719925474099199n;
const anotherBigInt = 123456789012345678901234567890n;

// 2. Brug af BigInt()-konstruktøren
const fromString = BigInt("98765432109876543210");
const fromNumber = BigInt(100);

// Du kan tjekke typen
console.log(typeof myFirstBigInt); // "bigint"
console.log(typeof 100);          // "number"
            

              
                Copy
              
            
          

Med BigInt fungerer vores tidligere mislykkede beregning nu perfekt:

            const maxSafePlusOne = BigInt(Number.MAX_SAFE_INTEGER) + 1n;
const maxSafePlusTwo = BigInt(Number.MAX_SAFE_INTEGER) + 2n;

console.log(maxSafePlusOne.toString());    // "9007199254740992"
console.log(maxSafePlusTwo.toString());    // "9007199254740993"

// Ligestilling fungerer som forventet
console.log(maxSafePlusOne === maxSafePlusTwo); // false
            

              
                Copy
              
            
          

Working with BigInt: Syntax and Operations

BigInts opfører sig meget som almindelige tal, men med et par afgørende forskelle, som enhver udvikler skal forstå for at undgå fejl.

Arithmetic Operations

Alle standard aritmetiske operatorer fungerer med BigInts:

• Addition: +
• Subtraction: -
• Multiplication: *
• Exponentiation: **
• Modulus (Remainder): %

Den ene operator, der opfører sig anderledes, er division (`/`).

            const a = 10n;
const b = 3n;

console.log(a + b); // 13n
console.log(a - b); // 7n
console.log(a * b); // 30n
console.log(a ** b); // 1000n
console.log(a % b); // 1n
            

              
                Copy
              
            
          

The Caveat of Division

Da BigInts kun kan repræsentere hele tal, afkortes resultatet af en division altid (den brøkdel kasseres). Den afrunder ikke.

            const a = 10n;
const b = 3n;
console.log(a / b); // 3n (ikke 3.333...n)

const c = 9n;
const d = 10n;
console.log(c / d); // 0n
            

              
                Copy
              
            
          

Dette er en kritisk skelnen. Hvis du har brug for at udføre beregninger med decimaler, er BigInt ikke det rigtige værktøj. Du skal fortsætte med at bruge Number eller et dedikeret decimalbibliotek.

Comparison and Equality

Sammenligningsoperatorer som >, <, >= og <= fungerer problemfrit mellem BigInts og endda mellem en BigInt og et Number.

            console.log(10n > 5);   // true
console.log(10n < 20);  // true
console.log(10n > 20n); // false
            

              
                Copy
              
            
          

Ligestilling er dog mere nuanceret og er en almindelig kilde til forvirring.

• Loose Equality (`==`): Denne operator udfører typekoercion. Den betragter en BigInt og et Number med samme matematiske værdi som lig med hinanden.
• Strict Equality (`===`): Denne operator udfører ikke typekoercion. Da BigInt og Number er forskellige typer, returnerer den altid false, når de sammenlignes.

            console.log(10n == 10);  // true - Vær forsigtig med dette!
console.log(10n === 10); // false - Anbefales for klarhed.

console.log(0n == 0);   // true
console.log(0n === 0);  // false
            

              
                Copy
              
            
          

Best Practice: For at undgå subtile fejl skal du altid bruge streng lighed (`===`) og være eksplicit omkring de typer, du sammenligner. Hvis du har brug for at sammenligne en BigInt og et Number, er det ofte mere klart at konvertere den ene til den anden først og holde potentielt præcisionstab i tankerne.

The Type Mismatch: A Strict Separation

JavaScript håndhæver en streng regel: du kan ikke blande BigInt- og Number-operander i de fleste aritmetiske operationer.

Forsøg på at gøre det vil resultere i en TypeError. Dette er et bevidst designvalg for at forhindre udviklere i ved et uheld at miste præcision.

            const myBigInt = 100n;
const myNumber = 50;

try {
  const result = myBigInt + myNumber; // Dette vil kaste en fejl
} catch (error) {
  console.log(error); // TypeError: Kan ikke blande BigInt og andre typer, brug eksplicitte konverteringer
}
            

              
                Copy
              
            
          

The Correct Approach: Explicit Conversion

For at udføre en operation mellem en BigInt og et Number skal du eksplicit konvertere en af dem.

            const myBigInt = 100n;
const myNumber = 50;

// Konverter Number til BigInt (sikkert)
const result1 = myBigInt + BigInt(myNumber);
console.log(result1); // 150n

// Konverter BigInt til Number (potentielt usikkert!)
const veryLargeBigInt = 900719925474099199n;

// Dette vil miste præcision!
const unsafeNumber = Number(veryLargeBigInt);
console.log(unsafeNumber); // 900719925474099200 - Værdien er blevet afrundet!

const safeResult = Number(100n) + myNumber;
console.log(safeResult); // 150
            

              
                Copy
              
            
          

Critical Rule: Konverter kun en BigInt til et Number, hvis du er helt sikker på, at det passer inden for det sikre heltalområde. Ellers skal du altid konvertere Number til en BigInt for at bevare præcisionen.

Practical Use Cases for BigInt in a Global Context

Behovet for BigInt er ikke et abstrakt akademisk problem. Det løser virkelige udfordringer, som udviklere står over for i forskellige internationale domæner.

1. High-Precision Timestamps

JavaScript's `Date.now()` returnerer antallet af millisekunder siden Unix-epoken. Selvom det er tilstrækkeligt til mange webapplikationer, er det ikke granulært nok til højtydende systemer. Mange distribuerede systemer, databaser og logningsrammer over hele kloden bruger nanosekund-præcision tidsstempler til nøjagtigt at bestille begivenheder. Disse tidsstempler er ofte repræsenteret som 64-bit heltal, som er for store til Number-typen.

            // Et tidsstempel fra et højopløsningssystem (f.eks. i nanosekunder)
const nanoTimestampStr = "1670000000123456789";

// Brug af Number resulterer i præcisionstab
const lostPrecision = Number(nanoTimestampStr);
console.log(lostPrecision); // 1670000000123456800 - Forkert!

// Brug af BigInt bevarer det perfekt
const correctTimestamp = BigInt(nanoTimestampStr);
console.log(correctTimestamp.toString()); // "1670000000123456789"

// Vi kan nu udføre nøjagtige beregninger
const oneSecondInNanos = 1_000_000_000n;
const nextSecond = correctTimestamp + oneSecondInNanos;
console.log(nextSecond.toString()); // "1670001000123456789"
            

              
                Copy
              
            
          

2. Unique Identifiers (IDs) from APIs

Et meget almindeligt scenarie er at interagere med API'er, der bruger 64-bit heltal til unikke objekt-ID'er. Dette er et mønster, der bruges af store globale platforme som Twitter (Snowflake IDs) og mange databasesystemer (f.eks. `BIGINT`-typen i SQL).

Når du henter data fra en sådan API, kan JSON-parseren i din browser eller Node.js-miljø forsøge at parse dette store ID som et `Number`, hvilket fører til datakorruption, før du overhovedet har en chance for at arbejde med det.

            // Et typisk JSON-svar fra en API
// Bemærk: ID'et er et stort tal, ikke en streng.
const jsonResponse = '{"id": 1367874743838343168, "text": "Hello, world!"}';

// Standard JSON.parse vil korrumpere ID'et
const parsedData = JSON.parse(jsonResponse);
console.log(parsedData.id); // 1367874743838343200 - Forkert ID!

// Løsning: Sørg for, at API'en sender store ID'er som strenge.
const safeJsonResponse = '{"id": "1367874743838343168", "text": "Hello, world!"}';

const safeParsedData = JSON.parse(safeJsonResponse);
const userId = BigInt(safeParsedData.id);
console.log(userId); // 1367874743838343168n - Korrekt!
            

              
                Copy
              
            
          

Derfor er det en bredt accepteret bedste praksis for API'er over hele verden at serialisere store heltal-ID'er som strenge i JSON-payloads for at sikre kompatibilitet med alle klienter.

3. Cryptography

Moderne kryptografi er bygget på matematik, der involverer ekstremt store heltal. Algoritmer som RSA er afhængige af operationer med tal, der er hundreder eller endda tusinder af bit lange. BigInt gør det muligt at udføre disse beregninger indbygget i JavaScript, hvilket er afgørende for webbaserede kryptografiske applikationer, såsom dem, der bruger Web Crypto API eller implementerer protokoller i Node.js.

Selvom et fuldt kryptografisk eksempel er komplekst, kan vi se en konceptuel demonstration:

            // To meget store primtal (kun til demonstrationsformål)
const p = 1143400375533529n;
const q = 982451653n; // En mindre en til eksemplet

// I RSA ganger du dem for at få modulus
const n = p * q;
console.log(n.toString()); // "1123281328905333100311297"

// Denne beregning ville være umulig med Number-typen.
// BigInt håndterer det ubesværet.
            

              
                Copy
              
            
          

4. Financial and Blockchain Applications

Når du beskæftiger dig med finans, især i forbindelse med kryptovalutaer, er præcision altafgørende. Mange kryptovalutaer, som Bitcoin, måler værdi i deres mindste enhed (f.eks. satoshis). Det samlede udbud af disse enheder kan nemt overstige `Number.MAX_SAFE_INTEGER`. BigInt er det perfekte værktøj til at håndtere disse store, præcise mængder uden at ty til flydende kommatalsaritmetik, som er tilbøjelig til afrundingsfejl.

            // 1 Bitcoin = 100.000.000 satoshis
const satoshisPerBTC = 100_000_000n;

// Det samlede udbud af Bitcoin er 21 millioner
const totalBTCSupply = 21_000_000n;

// Beregn det samlede antal satoshis
const totalSatoshis = totalBTCSupply * satoshisPerBTC;

// 2.100.000.000.000.000 - Dette er 2,1 kvadrillioner
console.log(totalSatoshis.toString());

// Denne værdi er større end Number.MAX_SAFE_INTEGER
console.log(totalSatoshis > BigInt(Number.MAX_SAFE_INTEGER)); // true
            

              
                Copy
              
            
          

Advanced Topics and Common Pitfalls

Serialization and JSON.stringify()

Et af de mest almindelige problemer, som udviklere står over for, er serialisering af objekter, der indeholder BigInts. Som standard ved `JSON.stringify()` ikke, hvordan man håndterer `bigint`-typen, og vil kaste en `TypeError`.

            const data = {
  id: 12345678901234567890n,
  user: 'alex'
};

try {
  JSON.stringify(data);
} catch (error) {
  console.log(error); // TypeError: Ved ikke, hvordan man serialiserer en BigInt
}
            

              
                Copy
              
            
          

Solution 1: Implement a `toJSON` method

Du kan fortælle `JSON.stringify`, hvordan man håndterer BigInts ved at tilføje en `toJSON`-metode til `BigInt.prototype`. Denne tilgang lapper den globale prototype, hvilket kan være uønsket i nogle delte miljøer, men det er meget effektivt.

            // A global patch. Use with consideration.
BigInt.prototype.toJSON = function() {
  return this.toString();
};

const data = { id: 12345678901234567890n, user: 'alex' };
const jsonString = JSON.stringify(data);

console.log(jsonString); // '{"id":"12345678901234567890","user":"alex"}'
            

              
                Copy
              
            
          

Solution 2: Use a replacer function

En sikrere, mere lokaliseret tilgang er at bruge argumentet `replacer` i `JSON.stringify`. Denne funktion kaldes for hvert nøgle/værdi-par og giver dig mulighed for at transformere værdien før serialisering.

            const data = { id: 12345678901234567890n, user: 'alex' };

const replacer = (key, value) => {
  if (typeof value === 'bigint') {
    return value.toString();
  }
  return value;
};

const jsonString = JSON.stringify(data, replacer);

console.log(jsonString); // '{"id":"12345678901234567890","user":"alex"}'
            

              
                Copy
              
            
          

Bitwise Operations

BigInt understøtter alle de bitvise operatorer, du er bekendt med fra `Number`-typen: `&` (AND), `|` (OR), `^` (XOR), `~` (NOT), `<<` (venstreforskydning) og `>>` (sign-propagating right shift). Disse er især nyttige, når du arbejder med lavniveau dataformater, tilladelser eller visse typer algoritmer.

            const permissions = 5n; // 0101 i binær
const READ_PERMISSION = 4n;   // 0100
const WRITE_PERMISSION = 2n;  // 0010

// Kontroller, om læsetilladelse er indstillet
console.log((permissions & READ_PERMISSION) > 0n); // true

// Kontroller, om skrivetilladelse er indstillet
console.log((permissions & WRITE_PERMISSION) > 0n); // false

// Tilføj skrivetilladelse
const newPermissions = permissions | WRITE_PERMISSION;
console.log(newPermissions); // 7n (som er 0111)
            

              
                Copy
              
            
          

Performance Considerations

Selvom BigInt er utrolig kraftfuld, er det vigtigt at forstå dens performance karakteristika:

• Number vs. BigInt: For heltal inden for det sikre område er standard `Number`-operationer betydeligt hurtigere. Dette skyldes, at de ofte kan kortlægges direkte til maskinniveauinstruktioner, der behandles af computerens CPU. BigInt-operationer, der er af vilkårlig størrelse, kræver mere komplekse softwarebaserede algoritmer.
• BigInt vs. Libraries: Native `BigInt` er generelt meget hurtigere end JavaScript-baserede store talbiblioteker. Implementeringen er en del af JavaScript-motoren (som V8 eller SpiderMonkey) og er skrevet i et lavere niveau sprog som C++, hvilket giver den en betydelig performancefordel.

The Golden Rule: Brug `Number` til alle numeriske beregninger, medmindre du har en specifik grund til at tro, at værdierne kan overstige `Number.MAX_SAFE_INTEGER`. Brug `BigInt`, når du har brug for dens muligheder, ikke som en standarderstatning for alle tal.

Browser and Environment Compatibility

BigInt er en moderne JavaScript-funktion, men dens understøttelse er nu udbredt i hele det globale økosystem.

• Web Browsers: Understøttet i alle større moderne browsere (Chrome 67+, Firefox 68+, Safari 14+, Edge 79+).
• Node.js: Understøttet siden version 10.4.0.

For projekter, der har brug for at understøtte meget gamle miljøer, kan transpilation ved hjælp af værktøjer som Babel være en mulighed, men dette kommer med en performance straf. I betragtning af den brede understøttelse i dag kan de fleste nye projekter bruge BigInt indbygget uden bekymring.

Conclusion and Best Practices

BigInt er en kraftfuld og væsentlig tilføjelse til JavaScript-sproget. Det giver en indbygget, effektiv og ergonomisk løsning på det langvarige problem med stor heltal aritmetik, hvilket gør det muligt at bygge en ny klasse af applikationer med JavaScript, fra kryptografi til højpræcisions datahåndtering.

For at bruge det effektivt og undgå almindelige faldgruber skal du huske disse bedste fremgangsmåder:

1. Use the `n` Suffix: Foretræk `123n` literal syntaksen til at oprette BigInts. Det er klart, præcist og undgår potentielt præcisionstab under oprettelsen.
2. Don't Mix Types: Husk, at du ikke kan blande BigInt og Number i aritmetiske operationer. Vær eksplicit med dine konverteringer: `BigInt()` eller `Number()`.
3. Prioritize Precision: Når du konverterer mellem typer, skal du altid favorisere at konvertere et `Number` til et `BigInt` for at forhindre utilsigtet præcisionstab.
4. Use Strict Equality: Brug `===` i stedet for `==` til sammenligninger for at undgå forvirrende adfærd forårsaget af type coercion.
5. Handle JSON Serialization: Planlæg for serialisering af BigInts. Brug en brugerdefineret `replacer`-funktion i `JSON.stringify` for en sikker, ikke-global løsning.
6. Choose the Right Tool: Brug `Number` til generel matematik inden for det sikre heltalområde for bedre performance. Ræk kun ud efter `BigInt`, når du virkelig har brug for dets vilkårlige præcisionsfunktioner.

Ved at omfavne BigInt og forstå dets regler kan du skrive mere robuste, nøjagtige og kraftfulde JavaScript-applikationer, der er i stand til at tackle numeriske udfordringer i enhver skala.