JavaScript BigInt: En omfattande guide till beräkningar med stora tal

Under många år stod JavaScript-utvecklare inför en tyst men betydande begränsning: språkets inbyggda förmåga att hantera tal. Även om JavaScripts Number-typ är perfekt för vardagliga beräkningar, fallerade den när den konfronterades med de verkligt massiva heltal som krävs inom områden som kryptografi, vetenskapliga beräkningar och moderna datasystem. Detta ledde till en värld av nödlösningar, tredjepartsbibliotek och subtila precisionsfel som var svåra att felsöka.

Den eran är över. Introduktionen av BigInt som en inbyggd primitiv typ i JavaScript har revolutionerat hur vi arbetar med stora tal. Det ger ett robust, ergonomiskt och effektivt sätt att utföra heltalsaritmetik med godtycklig precision, direkt i språket.

Denna omfattande guide är för utvecklare över hela världen. Vi kommer att dyka djupt ner i "varför, vad och hur" gällande BigInt. Oavsett om du bygger en finansiell applikation, interagerar med en blockkedja eller bara försöker förstå varför ditt stora unika ID från ett API beter sig konstigt, kommer den här artikeln att ge dig kunskapen för att bemästra BigInt.

Problemet: Gränserna för JavaScripts Number-typ

Innan vi kan uppskatta lösningen måste vi helt förstå problemet. Under större delen av sin historia har JavaScript bara haft en tal-typ: Number-typen. Under huven representeras den som ett IEEE 754 64-bitars flyttal med dubbel precision. Detta format är utmärkt för att representera ett brett spektrum av värden, inklusive decimaltal, men det har en kritisk begränsning när det gäller heltal.

Möt MAX_SAFE_INTEGER

På grund av dess flyttalsrepresentation finns det en gräns för storleken på ett heltal som kan representeras med perfekt precision. Denna gräns exponeras via en konstant: Number.MAX_SAFE_INTEGER.

Dess värde är 2⁵³ - 1, vilket är 9 007 199 254 740 991. Låt oss för enkelhetens skull kalla det nio biljarder.

Alla heltal inom intervallet -Number.MAX_SAFE_INTEGER till +Number.MAX_SAFE_INTEGER anses vara ett "säkert heltal". Det innebär att det kan representeras exakt och jämföras korrekt. Men vad händer när vi går utanför detta intervall?

Låt oss se det i praktiken:

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

// Låt oss addera 1 till det
console.log(maxSafe + 1);    // 9007199254740992 - Detta ser korrekt ut

// Låt oss addera ytterligare 1
console.log(maxSafe + 2);    // 9007199254740992 - Oj då. Felaktigt resultat.

// Det blir värre
console.log(maxSafe + 3);    // 9007199254740994 - Vänta, va?
console.log(maxSafe + 4);    // 9007199254740996 - Den hoppar över tal!

// Jämlikhetskontroll misslyckas också
console.log(maxSafe + 1 === maxSafe + 2); // true - Det här är matematiskt fel!
            

              
                Copy
              
            
          

Som du kan se, så fort vi överskrider Number.MAX_SAFE_INTEGER, kan JavaScript inte längre garantera precisionen i våra beräkningar. Talrepresentationen börjar få luckor, vilket leder till avrundningsfel och felaktiga resultat. Detta är en mardröm för applikationer som kräver noggrannhet med stora heltal.

De gamla nödlösningarna

Under många år förlitade sig den globala utvecklargemenskapen på externa bibliotek för att lösa detta problem. Bibliotek som bignumber.js, decimal.js och long.js blev standardverktyg. De fungerade genom att representera stora tal som strängar eller arrayer av siffror och implementera aritmetiska operationer i mjukvara.

Även om de var effektiva, kom dessa bibliotek med kompromisser:

• Prestanda-overhead: Operationerna var betydligt långsammare än inbyggda talberäkningar.
• Paketstorlek: De lade till vikt i applikationspaketen, ett bekymmer för webbprestanda.
• Annorlunda syntax: Utvecklare var tvungna att använda objektmetoder (t.ex. a.add(b)) istället för vanliga aritmetiska operatorer (a + b), vilket gjorde koden mindre intuitiv.

Introduktion till BigInt: Den inbyggda lösningen

BigInt introducerades i ES2020 för att lösa detta problem inbyggt. En BigInt är en ny primitiv typ i JavaScript som ger ett sätt att representera heltal större än 2⁵³ - 1.

Nyckelfunktionen hos BigInt är att dess storlek inte är fast. Det kan representera godtyckligt stora heltal, begränsat endast av det tillgängliga minnet i värdsystemet. Detta eliminerar helt de precisionsproblem vi såg med Number-typen.

Hur man skapar en BigInt

Det finns två huvudsakliga sätt att skapa en BigInt:

1. Lägga till `n` efter en heltalsliteral: Detta är den enklaste och vanligaste metoden.
2. Använda konstruktorfunktionen `BigInt()`: Detta är användbart när man konverterar ett värde från en annan typ, som en sträng eller ett tal.

Så här ser de ut i kod:

            // 1. Använda suffixet 'n'
const myFirstBigInt = 900719925474099199n;
const anotherBigInt = 123456789012345678901234567890n;

// 2. Använda konstruktorn BigInt()
const fromString = BigInt("98765432109876543210");
const fromNumber = BigInt(100);

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

              
                Copy
              
            
          

Med BigInt fungerar vår tidigare misslyckade beräkning 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"

// Jämlikhet fungerar som förväntat
console.log(maxSafePlusOne === maxSafePlusTwo); // false
            

              
                Copy
              
            
          

Att arbeta med BigInt: Syntax och operationer

BigInts beter sig i stort sett som vanliga tal, men med några avgörande skillnader som varje utvecklare måste förstå för att undvika buggar.

Aritmetiska operationer

Alla standardaritmetiska operatorer fungerar med BigInts:

• Addition: +
• Subtraktion: -
• Multiplikation: *
• Exponentiering: **
• Modulus (Rest): %

Den enda operatorn som beter sig annorlunda är 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
              
            
          

Förbehållet med division

Eftersom BigInts bara kan representera heltal, trunkeras resultatet av en division alltid (decimaldelen tas bort). Det avrundas inte.

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

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

              
                Copy
              
            
          

Detta är en kritisk skillnad. Om du behöver utföra beräkningar med decimaler är BigInt inte rätt verktyg. Du skulle behöva fortsätta använda Number eller ett dedikerat decimalbibliotek.

Jämförelse och jämlikhet

Jämförelseoperatorer som >, <, >= och <= fungerar sömlöst mellan BigInts, och även mellan en BigInt och en Number.

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

              
                Copy
              
            
          

Jämlikhet är dock mer nyanserad och är en vanlig källa till förvirring.

• Lös jämlikhet (`==`): Denna operator utför typkonvertering. Den anser att en BigInt och en Number med samma matematiska värde är lika.
• Strikt jämlikhet (`===`): Denna operator utför inte typkonvertering. Eftersom BigInt och Number är olika typer kommer den alltid att returnera false när de jämförs.

            console.log(10n == 10);  // true - Var försiktig med detta!
console.log(10n === 10); // false - Rekommenderas för tydlighetens skull.

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

              
                Copy
              
            
          

Bästa praxis: För att undvika subtila buggar, använd alltid strikt jämlikhet (`===`) och var explicit med de typer du jämför. Om du behöver jämföra en BigInt och en Number är det ofta tydligare att först konvertera den ena till den andra, med hänsyn till potentiell precisionsförlust.

Typkonflikten: En strikt separation

JavaScript upprätthåller en strikt regel: du kan inte blanda BigInt- och Number-operander i de flesta aritmetiska operationer.

Försök att göra det kommer att resultera i ett TypeError. Detta är ett medvetet designval för att förhindra att utvecklare oavsiktligt förlorar precision.

            const myBigInt = 100n;
const myNumber = 50;

try {
  const result = myBigInt + myNumber; // Detta kommer att kasta ett fel
} catch (error) {
  console.log(error); // TypeError: Cannot mix BigInt and other types, use explicit conversions
}
            

              
                Copy
              
            
          

Den korrekta metoden: Explicita konverteringar

För att utföra en operation mellan en BigInt och en Number måste du explicit konvertera en av dem.

            const myBigInt = 100n;
const myNumber = 50;

// Konvertera Number till BigInt (säkert)
const result1 = myBigInt + BigInt(myNumber);
console.log(result1); // 150n

// Konvertera BigInt till Number (potentiellt osäkert!)
const veryLargeBigInt = 900719925474099199n;

// Detta kommer att förlora precision!
const unsafeNumber = Number(veryLargeBigInt);
console.log(unsafeNumber); // 900719925474099200 - Värdet har avrundats!

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

              
                Copy
              
            
          

Kritisk regel: Konvertera endast en BigInt till en Number om du är helt säker på att den passar inom det säkra heltalsintervallet. Annars, konvertera alltid Number till en BigInt för att bibehålla precisionen.

Praktiska användningsfall för BigInt i en global kontext

Behovet av BigInt är inte ett abstrakt akademiskt problem. Det löser verkliga utmaningar som utvecklare står inför i olika internationella domäner.

1. Högprecisionstidsstämplar

JavaScript's `Date.now()` returnerar antalet millisekunder sedan Unix-epoken. Även om det är tillräckligt för många webbapplikationer, är det inte tillräckligt granulärt för högpresterande system. Många distribuerade system, databaser och loggningsramverk över hela världen använder nanosekund-precisionstidsstämplar för att korrekt ordna händelser. Dessa tidsstämplar representeras ofta som 64-bitars heltal, vilket är för stort för Number-typen.

            // En tidsstämpel från ett högupplöst system (t.ex. i nanosekunder)
const nanoTimestampStr = "1670000000123456789";

// Att använda Number resulterar i precisionsförlust
const lostPrecision = Number(nanoTimestampStr);
console.log(lostPrecision); // 1670000000123456800 - Felaktigt!

// Med BigInt bevaras den perfekt
const correctTimestamp = BigInt(nanoTimestampStr);
console.log(correctTimestamp.toString()); // "1670000000123456789"

// Nu kan vi utföra exakta beräkningar
const oneSecondInNanos = 1_000_000_000n;
const nextSecond = correctTimestamp + oneSecondInNanos;
console.log(nextSecond.toString()); // "1670001000123456789"
            

              
                Copy
              
            
          

2. Unika identifierare (ID:n) från API:er

Ett mycket vanligt scenario är att interagera med API:er som använder 64-bitars heltal för unika objekt-ID:n. Detta är ett mönster som används av stora globala plattformar som Twitter (Snowflake IDs) och många databassystem (t.ex. BIGINT-typen i SQL).

När du hämtar data från ett sådant API kan JSON-parsern i din webbläsare eller Node.js-miljö försöka tolka detta stora ID som en Number, vilket leder till datakorruption innan du ens har en chans att arbeta med det.

            // Ett typiskt JSON-svar från ett API
// Notera: ID:t är ett stort tal, inte en sträng.
const jsonResponse = '{"id": 1367874743838343168, "text": "Hello, world!"}';

// Standard JSON.parse kommer att korrumpera ID:t
const parsedData = JSON.parse(jsonResponse);
console.log(parsedData.id); // 1367874743838343200 - Fel ID!

// Lösning: Se till att API:et skickar stora ID:n som strängar.
const safeJsonResponse = '{"id": "1367874743838343168", "text": "Hello, world!"}';

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

              
                Copy
              
            
          

Detta är anledningen till att det är en allmänt accepterad bästa praxis för API:er världen över att serialisera stora heltals-ID:n som strängar i JSON-nyttolaster för att säkerställa kompatibilitet med alla klienter.

3. Kryptografi

Modern kryptografi bygger på matematik som involverar extremt stora heltal. Algoritmer som RSA förlitar sig på operationer med tal som är hundratals eller till och med tusentals bitar långa. BigInt gör det möjligt att utföra dessa beräkningar inbyggt i JavaScript, vilket är avgörande för webbaserade kryptografiska applikationer, som de som använder Web Crypto API eller implementerar protokoll i Node.js.

Även om ett fullständigt kryptografiskt exempel är komplicerat, kan vi se en konceptuell demonstration:

            // Två väldigt stora primtal (endast i demonstrationssyfte)
const p = 1143400375533529n;
const q = 982451653n; // Ett mindre för exemplets skull

// I RSA multiplicerar du dem för att få modulus
const n = p * q;
console.log(n.toString()); // "1123281328905333100311297"

// Denna beräkning skulle vara omöjlig med typen Number.
// BigInt hanterar det utan problem.
            

              
                Copy
              
            
          

4. Finansiella och blockkedjeapplikationer

När man hanterar finans, särskilt i samband med kryptovalutor, är precision av yttersta vikt. Många kryptovalutor, som Bitcoin, mäter värde i sin minsta enhet (t.ex. satoshis). Det totala utbudet av dessa enheter kan lätt överskrida Number.MAX_SAFE_INTEGER. BigInt är det perfekta verktyget för att hantera dessa stora, exakta kvantiteter utan att tillgripa flyttalsaritmetik, som är benägen för avrundningsfel.

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

// Totala utbudet av Bitcoin är 21 miljoner
const totalBTCSupply = 21_000_000n;

// Beräkna totalt antal satoshis
const totalSatoshis = totalBTCSupply * satoshisPerBTC;

// 2 100 000 000 000 000 - Detta är 2,1 biljarder
console.log(totalSatoshis.toString());

// Detta värde är större än Number.MAX_SAFE_INTEGER
console.log(totalSatoshis > BigInt(Number.MAX_SAFE_INTEGER)); // true
            

              
                Copy
              
            
          

Avancerade ämnen och vanliga fallgropar

Serialisering och JSON.stringify()

Ett av de vanligaste problemen utvecklare stöter på är att serialisera objekt som innehåller BigInts. Som standard vet JSON.stringify() inte hur man hanterar typen bigint och kommer att kasta ett TypeError.

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

try {
  JSON.stringify(data);
} catch (error) {
  console.log(error); // TypeError: Do not know how to serialize a BigInt
}
            

              
                Copy
              
            
          

Lösning 1: Implementera en `toJSON`-metod

Du kan berätta för `JSON.stringify` hur man hanterar BigInts genom att lägga till en `toJSON`-metod i `BigInt.prototype`. Detta tillvägagångssätt patchar den globala prototypen, vilket kan vara oönskat i vissa delade miljöer, men det är mycket effektivt.

            // En global patch. Använd med eftertanke.
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
              
            
          

Lösning 2: Använd en replacer-funktion

Ett säkrare, mer lokaliserat tillvägagångssätt är att använda `replacer`-argumentet i `JSON.stringify`. Denna funktion anropas för varje nyckel/värde-par och låter dig omvandla värdet före 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
              
            
          

Bitvisa operationer

BigInt stöder alla bitvisa operatorer som du är bekant med från Number-typen: `&` (AND), `|` (OR), `^` (XOR), `~` (NOT), `<<` (vänsterskift) och `>>` (tecken-propagerande högerskift). Dessa är särskilt användbara när man arbetar med lågnivå-dataformat, behörigheter eller vissa typer av algoritmer.

            const permissions = 5n; // 0101 binärt
const READ_PERMISSION = 4n;   // 0100
const WRITE_PERMISSION = 2n;  // 0010

// Kontrollera om läsbehörighet är satt
console.log((permissions & READ_PERMISSION) > 0n); // true

// Kontrollera om skrivbehörighet är satt
console.log((permissions & WRITE_PERMISSION) > 0n); // false

// Lägg till skrivbehörighet
const newPermissions = permissions | WRITE_PERMISSION;
console.log(newPermissions); // 7n (vilket är 0111)
            

              
                Copy
              
            
          

Prestandaöverväganden

Även om BigInt är otroligt kraftfullt är det viktigt att förstå dess prestandaegenskaper:

• Number vs. BigInt: För heltal inom det säkra intervallet är standardoperationer med Number betydligt snabbare. Detta beror på att de ofta kan mappas direkt till instruktioner på maskinnivå som bearbetas av datorns CPU. BigInt-operationer, som är av godtycklig storlek, kräver mer komplexa mjukvarubaserade algoritmer.
• BigInt vs. Bibliotek: Inbyggt BigInt är generellt sett mycket snabbare än JavaScript-baserade bibliotek för stora tal. Implementeringen är en del av JavaScript-motorn (som V8 eller SpiderMonkey) och är skriven i ett lägre nivåspråk som C++, vilket ger den en betydande prestandafördel.

Den gyllene regeln: Använd Number för alla numeriska beräkningar om du inte har en specifik anledning att tro att värdena kan överskrida Number.MAX_SAFE_INTEGER. Använd BigInt när du behöver dess kapacitet, inte som en standardersättning för alla tal.

Kompatibilitet med webbläsare och miljöer

BigInt är en modern JavaScript-funktion, men dess stöd är nu utbrett över det globala ekosystemet.

• Webbläsare: Stöds i alla större moderna webbläsare (Chrome 67+, Firefox 68+, Safari 14+, Edge 79+).
• Node.js: Stöds sedan version 10.4.0.

För projekt som behöver stödja mycket gamla miljöer kan transpileriing med verktyg som Babel vara ett alternativ, men detta medför en prestandaförlust. Med tanke på det breda stödet idag kan de flesta nya projekt använda BigInt inbyggt utan problem.

Slutsats och bästa praxis

BigInt är ett kraftfullt och väsentligt tillägg till JavaScript-språket. Det ger en inbyggd, effektiv och ergonomisk lösning på det långvariga problemet med aritmetik för stora heltal, vilket möjliggör en ny klass av applikationer som kan byggas med JavaScript, från kryptografi till högprecisionsdatahantering.

För att använda det effektivt och undvika vanliga fallgropar, ha dessa bästa praxis i åtanke:

1. Använd `n`-suffixet: Föredra literalsyntaxen `123n` för att skapa BigInts. Det är tydligt, koncist och undviker potentiell precisionsförlust vid skapandet.
2. Blanda inte typer: Kom ihåg att du inte kan blanda BigInt och Number i aritmetiska operationer. Var explicit med dina konverteringar: `BigInt()` eller `Number()`.
3. Prioritera precision: När du konverterar mellan typer, föredra alltid att konvertera en `Number` till en `BigInt` för att förhindra oavsiktlig precisionsförlust.
4. Använd strikt jämlikhet: Använd `===` istället för `==` för jämförelser för att undvika förvirrande beteende orsakat av typkonvertering.
5. Hantera JSON-serialisering: Planera för serialisering av BigInts. Använd en anpassad `replacer`-funktion i `JSON.stringify` för en säker, icke-global lösning.
6. Välj rätt verktyg: Använd `Number` för allmän matematik inom det säkra heltalsintervallet för bättre prestanda. Använd endast `BigInt` när du verkligen behöver dess godtyckliga precisionskapacitet.

Genom att omfamna BigInt och förstå dess regler kan du skriva mer robusta, exakta och kraftfulla JavaScript-applikationer som kan hantera numeriska utmaningar av alla skalor.