JavaScript BigInt-aritmetik: En djupdykning i beräkningar med stora tal och precisionshantering

Under många år stod JavaScript-utvecklare inför en tyst men betydande begränsning: oförmågan att nativt och korrekt representera mycket stora heltal. Alla tal i JavaScript representerades traditionellt som IEEE 754 flyttal med dubbel precision, vilket sätter ett tak för heltalsprecisionen. När beräkningar involverade tal större än vad som säkert kunde hanteras var utvecklare tvungna att förlita sig på tredjepartsbibliotek. Detta ändrades med introduktionen av BigInt i ECMAScript 2020 (ES11), en revolutionerande funktion som förde in heltal med godtycklig precision i språkkärnan.

Denna omfattande guide är utformad för en global publik av utvecklare. Vi kommer att utforska de problem BigInt löser, hur man använder det för exakt aritmetik, dess verkliga tillämpningar inom områden som kryptografi och finans, och de vanliga fallgroparna att undvika. Oavsett om du bygger en fintech-plattform, en vetenskaplig simulering eller interagerar med system som använder 64-bitars identifierare, är förståelsen för BigInt avgörande för modern JavaScript-utveckling.

Glastaket för JavaScripts `Number`-typ

Innan vi kan uppskatta lösningen måste vi först förstå problemet. JavaScripts standardtyp Number, även om den är mångsidig, har en fundamental begränsning när det gäller heltalsprecision. Detta är inte en bugg; det är en direkt konsekvens av dess design baserad på IEEE 754-standarden för flyttalsaritmetik.

Att förstå `Number.MAX_SAFE_INTEGER`

Typen Number kan bara säkert representera heltal upp till ett visst värde. Denna tröskel exponeras som en statisk egenskap: Number.MAX_SAFE_INTEGER.

Dess värde är 9,007,199,254,740,991, eller 2⁵³ - 1. Varför just detta tal? I de 64 bitar som används för ett flyttal med dubbel precision är 52 bitar dedikerade till mantissan (de signifikanta siffrorna), en bit för tecknet och 11 bitar för exponenten. Denna struktur möjliggör ett mycket stort värdeintervall men begränsar den kontinuerliga, luckfria representationen av heltal.

Låt oss se vad som händer när vi försöker överskrida denna gräns:

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

const oneMore = maxSafeInt + 1;
console.log(oneMore); // 9007199254740992

const twoMore = maxSafeInt + 2;
console.log(twoMore); // 9007199254740992 - Oj då!

console.log(oneMore === twoMore); // true

            

              
                Copy
              
            
          

Som du kan se, när vi väl har passerat tröskeln, förlorar talsystemet sin förmåga att representera varje konsekutivt heltal. maxSafeInt + 1 och maxSafeInt + 2 utvärderas till samma värde. Denna tysta förlust av precision kan leda till katastrofala buggar i applikationer som är beroende av exakt heltalsaritmetik, såsom finansiella beräkningar eller hantering av stora databas-ID:n.

När spelar detta roll?

Denna begränsning är inte bara en teoretisk kuriositet. Den har betydande konsekvenser i verkligheten:

• Databas-ID:n: Många moderna databassystem, som PostgreSQL, använder en 64-bitars heltals-typ (BIGINT) för primärnycklar. Dessa ID:n kan lätt överskrida Number.MAX_SAFE_INTEGER. När en JavaScript-klient hämtar detta ID kan det avrundas felaktigt, vilket leder till datakorruption eller oförmåga att hämta rätt post.
• API-integrationer: Tjänster som Twitter (nu X) använder 64-bitars heltal kallade "Snowflakes" för tweet-ID:n. Att hantera dessa ID:n korrekt i en JavaScript-frontend kräver särskild omsorg.
• Kryptografi: Kryptografiska operationer involverar ofta aritmetik med extremt stora primtal, långt bortom kapaciteten hos standardtypen Number.
• Tidsstämplar med hög precision: Vissa system tillhandahåller tidsstämplar med nanosekundprecision, ofta representerade som ett 64-bitars heltal från en epok. Att lagra detta i en standard-Number skulle trunkera dess precision.

Här kommer BigInt: Lösningen för heltal med godtycklig precision

BigInt introducerades specifikt för att lösa detta problem. Det är en separat numerisk primitiv typ i JavaScript som kan representera heltal med godtycklig precision. Detta innebär att ett BigInt inte är begränsat av ett fast antal bitar; det kan växa eller krympa för att rymma värdet det håller, endast begränsat av det tillgängliga minnet i värdsystemet.

Skapa ett BigInt

Det finns två primära sätt att skapa ett BigInt-värde:

1. Lägg till `n` efter en heltalsliteral: Detta är den enklaste och vanligaste metoden.
2. Använd konstruktorfunktionen `BigInt()`: Detta är användbart för att konvertera strängar eller Numbers till BigInts.

Här är några exempel:

            
// Använder 'n'-suffixet
const aLargeNumber = 9007199254740991n;
const anEvenLargerNumber = 1234567890123456789012345678901234567890n;

// Använder BigInt()-konstruktorn
const fromString = BigInt("98765432109876543210");
const fromNumber = BigInt(100); // Skapar 100n

// Låt oss verifiera deras typ
console.log(typeof aLargeNumber); // "bigint"
console.log(typeof fromString);   // "bigint"

            

              
                Copy
              
            
          

Viktigt att notera: Du kan inte använda operatorn `new` med `BigInt()`, eftersom det är en primitiv typ, inte ett objekt. `new BigInt()` kommer att kasta ett `TypeError`.

Grundläggande aritmetik med BigInt

BigInt stöder de vanliga aritmetiska operatorerna du är bekant med, men de beter sig strikt inom heltalsdomänen.

Addition, subtraktion och multiplikation

Dessa operatorer fungerar precis som du förväntar dig, men med förmågan att hantera enorma tal utan att förlora precision.

            
const num1 = 12345678901234567890n;
const num2 = 98765432109876543210n;

// Addition
console.log(num1 + num2); // 111111111011111111100n

// Subtraktion
console.log(num2 - num1); // 86419753208641975320n

// Multiplikation
console.log(num1 * 2n);   // 24691357802469135780n

            

              
                Copy
              
            
          

Division (`/`)

Det är här BigInts beteende skiljer sig avsevärt från standarddivision med Number. Eftersom BigInts endast kan representera heltal, trunkeras resultatet av en division alltid mot noll (bråkdelen tas bort).

            
const dividend = 10n;
const divisor = 3n;

console.log(dividend / divisor); // 3n (inte 3.333...)

const negativeDividend = -10n;
console.log(negativeDividend / divisor); // -3n

// För jämförelse med Number-division
console.log(10 / 3); // 3.3333333333333335

            

              
                Copy
              
            
          

Denna heltalsdivision är avgörande. Om du behöver utföra beräkningar som kräver decimalprecision är BigInt inte rätt verktyg. Du skulle behöva vända dig till bibliotek som `Decimal.js` eller hantera decimaldelen manuellt (till exempel genom att arbeta med den minsta valutaenheten i finansiella beräkningar).

Rest (`%`) och exponentiering (`**`)

Restoperatorn (%) och exponentieringsoperatorn (**) fungerar också som förväntat med BigInt-värden.

            
console.log(10n % 3n); // 1n
console.log(-10n % 3n); // -1n

// Exponentiering kan skapa riktigt massiva tal
const base = 2n;
const exponent = 100n;
const hugeNumber = base ** exponent;
console.log(hugeNumber); // 1267650600228229401496703205376n

            

              
                Copy
              
            
          

Den strikta regeln: Blanda inte `BigInt` och `Number`

En av de viktigaste reglerna att komma ihåg när man arbetar med BigInt är att du inte kan blanda BigInt- och Number-operander i de flesta aritmetiska operationer. Att försöka göra det resulterar i ett `TypeError`.

Detta designval var avsiktligt. Det förhindrar utvecklare från att oavsiktligt förlora precision när ett BigInt implicit omvandlas till ett Number. Språket tvingar dig att vara explicit med dina avsikter.

            
const myBigInt = 100n;
const myNumber = 50;

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

            

              
                Copy
              
            
          

Det korrekta tillvägagångssättet: Explicit konvertering

För att utföra en operation mellan ett BigInt och ett Number måste du explicit konvertera den ena till den andras typ.

            
const myBigInt = 100n;
const myNumber = 50;

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

// Konvertera BigInt till ett Number (använd med försiktighet!)
const result2 = Number(myBigInt) + myNumber;
console.log(result2); // 150

            

              
                Copy
              
            
          

Varning: Att konvertera ett BigInt till ett Number med `Number()` är farligt om BigInt-värdet ligger utanför det säkra heltalsintervallet. Detta kan återinföra just de precisionsfel som BigInt är utformat för att förhindra.

            
const veryLargeBigInt = 9007199254740993n;
const convertedToNumber = Number(veryLargeBigInt);

console.log(veryLargeBigInt);      // 9007199254740993n
console.log(convertedToNumber);  // 9007199254740992 - Precision förlorad!

            

              
                Copy
              
            
          

Den allmänna regeln är: om du arbetar med potentiellt stora heltal, stanna inom BigInt-ekosystemet för alla dina beräkningar. Konvertera endast tillbaka till ett Number om du är säker på att värdet ligger inom det säkra intervallet.

Jämförelse- och logiska operatorer

Medan aritmetiska operatorer är strikta med typblandning, är jämförelse- och logiska operatorer mer överseende.

Relationella jämförelser (`>`, `<`, `>=`, `<=`)

Du kan säkert jämföra ett BigInt med ett Number. JavaScript hanterar jämförelsen av deras matematiska värden korrekt.

            
console.log(10n > 5);   // true
console.log(10n < 20);  // true
console.log(100n >= 100); // true
console.log(99n <= 100);  // true

            

              
                Copy
              
            
          

Jämlikhet (`==` vs. `===`)

Skillnaden mellan lös jämlikhet (==) och strikt jämlikhet (===) är mycket viktig med BigInt.

• Strikt jämlikhet (===) kontrollerar både värde och typ. Eftersom BigInt och Number är olika typer kommer 10n === 10 alltid att vara falskt.
• Lös jämlikhet (==) utför typkonvertering. Den kommer att anse 10n == 10 vara sant eftersom deras matematiska värden är desamma.

            
console.log(10n == 10);   // true
console.log(10n === 10);  // false (olika typer)
console.log(10n === 10n); // true (samma värde och typ)

            

              
                Copy
              
            
          

För tydlighetens skull och för att undvika oväntat beteende är det oftast bäst att använda strikt jämlikhet och se till att du jämför värden av samma typ.

Boolesk kontext

Precis som Numbers kan BigInts utvärderas i en boolesk kontext (t.ex. i en `if`-sats). Värdet `0n` anses vara falsy, medan alla andra BigInt-värden (positiva eller negativa) anses vara truthy.

            
if (0n) {
  // Denna kod kommer inte att köras
} else {
  console.log("0n är falsy");
}

if (1n && -10n) {
  console.log("Icke-noll BigInts är truthy");
}

            

              
                Copy
              
            
          

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

Nu när vi förstår mekaniken, låt oss utforska var BigInt briljerar i verkliga, internationella tillämpningar.

1. Finansiell teknologi (FinTech)

Flyttalsaritmetik är ökänt problematiskt för finansiella beräkningar på grund av avrundningsfel. En vanlig global praxis är att representera monetära värden som heltal av den minsta valutaenheten (t.ex. cent för USD, yen för JPY, satoshis för Bitcoin).

Medan vanliga Numbers kan räcka för mindre belopp, blir BigInt ovärderligt när man hanterar stora transaktioner, aggregerade summor eller kryptovalutor, som ofta involverar mycket stora tal.

            
// Representerar en stor överföring i den minsta enheten (t.ex. Wei för Ethereum)
const walletBalance = 1234567890123456789012345n; // En stor mängd Wei
const transactionAmount = 9876543210987654321n;

const newBalance = walletBalance - transactionAmount;

console.log(`Nytt saldo: ${newBalance.toString()} Wei`);
// Nytt saldo: 1224691346912369134691246 Wei

            

              
                Copy
              
            
          

Att använda BigInt säkerställer att varje enskild enhet redovisas, vilket eliminerar de avrundningsfel som kan uppstå med flyttalsmatematik.

2. Kryptografi

Modern kryptografi, såsom RSA-algoritmen som används i TLS/SSL-kryptering över hela webben, förlitar sig på aritmetik med extremt stora primtal. Dessa tal är ofta 2048 bitar eller större, vilket långt överstiger kapaciteten hos JavaScripts Number-typ.

Med BigInt kan kryptografiska algoritmer nu implementeras eller polyfyllas direkt i JavaScript, vilket möjliggör nya möjligheter för säkerhetsverktyg i webbläsaren och WebAssembly-drivna applikationer.

3. Hantering av 64-bitars identifierare

Som nämnts tidigare genererar många distribuerade system och databaser 64-bitars unika identifierare. Detta är ett vanligt mönster i storskaliga system utvecklade av företag över hela världen.

Före BigInt var JavaScript-applikationer som konsumerade API:er som returnerade dessa ID:n tvungna att behandla dem som strängar för att undvika precisionsförlust. Detta var en besvärlig nödlösning.

            
// Ett API-svar med ett 64-bitars användar-ID
const apiResponse = '{"userId": "1143534363363377152", "username": "dev_user"}';

// Gamla sättet (tolka som sträng)
const userDataString = JSON.parse(apiResponse);
console.log(userDataString.userId); // "1143534363363377152"
// All matematik skulle kräva ett bibliotek eller strängmanipulation.

// Nya sättet (med en anpassad reviver och BigInt)
const userDataBigInt = JSON.parse(apiResponse, (key, value) => {
  // En enkel kontroll för att konvertera potentiella ID-fält till BigInt
  if (key === 'userId' && typeof value === 'string' && /^[0-9]+$/.test(value)) {
    return BigInt(value);
  }
  return value;
});

console.log(userDataBigInt.userId); // 1143534363363377152n
console.log(typeof userDataBigInt.userId); // "bigint"

            

              
                Copy
              
            
          

Med BigInt kan dessa ID:n representeras som sin korrekta numeriska typ, vilket möjliggör korrekt sortering, jämförelse och lagring.

4. Vetenskapliga och matematiska beräkningar

Områden som talteori, kombinatorik och fysiksimuleringar kräver ofta beräkningar som producerar heltal större än Number.MAX_SAFE_INTEGER. Till exempel kan beräkning av stora fakulteter eller termer i Fibonacci-sekvensen göras enkelt med BigInt.

            
function factorial(n) {
  // Använd BigInts från början
  let result = 1n;
  for (let i = 2n; i <= n; i++) {
    result *= i;
  }
  return result;
}

// Beräkna fakulteten av 50
const fact50 = factorial(50n);
console.log(fact50.toString());
// 30414093201713378043612608166064768844377641568960512000000000000n

            

              
                Copy
              
            
          

Avancerade ämnen och vanliga fallgropar

Även om BigInt är kraftfullt finns det flera nyanser och potentiella problem att vara medveten om.

JSON-serialisering: En stor fälla

En betydande utmaning uppstår när du försöker serialisera ett objekt som innehåller ett BigInt till en JSON-sträng. Som standard kommer `JSON.stringify()` att kasta ett `TypeError` när det stöter på ett BigInt.

            
const data = {
  id: 12345678901234567890n,
  status: "active"
};

try {
  JSON.stringify(data);
} catch (error) {
  console.error(error); // TypeError: Vet inte hur man serialiserar ett BigInt
}

            

              
                Copy
              
            
          

Detta beror på att JSON-specifikationen inte har en datatyp för godtyckligt stora heltal, och en tyst konvertering till ett standardnummer kan leda till precisionsförlust. För att hantera detta måste du tillhandahålla en anpassad serialiseringsstrategi.

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

Du kan lägga till en `toJSON`-metod i `BigInt.prototype`. Denna metod kommer automatiskt att anropas av `JSON.stringify()`.

            
// Lägg till detta i din applikations konfigurationsfil
BigInt.prototype.toJSON = function() {
  return this.toString();
};

const data = { id: 12345678901234567890n, status: "active" };
const jsonString = JSON.stringify(data);

console.log(jsonString); // "{"id":"12345678901234567890","status":"active"}"

            

              
                Copy
              
            
          

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

Om du inte vill modifiera en global prototyp kan du skicka en `replacer`-funktion till `JSON.stringify()`.

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

const data = { id: 12345678901234567890n, status: "active" };
const jsonString = JSON.stringify(data, replacer);

console.log(jsonString); // "{"id":"12345678901234567890","status":"active"}"

            

              
                Copy
              
            
          

Kom ihåg att du också kommer att behöva en motsvarande `reviver`-funktion när du använder `JSON.parse()` för att konvertera strängrepresentationen tillbaka till ett BigInt, som visades i exemplet med 64-bitars ID tidigare.

Bitvisa operationer

BigInt stöder också bitvisa operationer (&, |, ^, ~, <<, >>), som behandlar BigInt som en sekvens av bitar i tvåkomplementsrepresentation. Detta är extremt användbart för lågnivå-datamanipulation, tolkning av binära protokoll eller implementering av vissa algoritmer.

            
const mask = 0b1111n; // En 4-bitars mask
const value = 255n;   // 0b11111111n

// Bitvis AND
console.log(value & mask); // 15n (vilket är 0b1111n)

// Vänsterskift
console.log(1n << 64n); // 18446744073709551616n (2^64)

            

              
                Copy
              
            
          

Observera att den osignerade högerskiftsoperatorn (>>>) inte stöds för BigInt, eftersom varje BigInt är signerat.

Prestandaöverväganden

Även om BigInt är ett kraftfullt verktyg är det inte en direkt ersättning för Number. Operationer på BigInts är generellt sett långsammare än deras Number-motsvarigheter eftersom de kräver mer komplex, variabel minnesallokering och beräkningslogik. För standardaritmetik som bekvämt ryms inom det säkra heltalsintervallet bör du fortsätta att använda typen Number för optimal prestanda.

Tumregeln är enkel: Använd Number som standard. Byt till BigInt endast när du vet att du kommer att hantera heltal som kan överskrida Number.MAX_SAFE_INTEGER.

Stöd i webbläsare och miljöer

BigInt är en del av ES2020-standarden och stöds brett i alla moderna webbläsare (Chrome, Firefox, Safari, Edge) och servermiljöer som Node.js (version 10.4.0 och senare). Det är dock inte tillgängligt i äldre webbläsare som Internet Explorer. Om du behöver stödja äldre miljöer måste du fortfarande förlita dig på tredjepartsbibliotek för stora tal och eventuellt använda en transpiler som Babel, som kan tillhandahålla en polyfill.

För en global publik är det alltid klokt att kontrollera en kompatibilitetsresurs som "Can I Use..." för att säkerställa att din målgrupp kan köra din kod utan problem.

Slutsats: En ny horisont för JavaScript

Introduktionen av BigInt markerar en betydande mognad av JavaScript-språket. Det adresserar direkt en långvarig begränsning och ger utvecklare möjlighet att bygga en ny klass av applikationer som kräver högprecision-heltalsaritmetik. Genom att tillhandahålla en inbyggd, nativ lösning eliminerar BigInt behovet av externa bibliotek för många vanliga användningsfall, vilket leder till renare, effektivare och säkrare kod.

Viktiga lärdomar för globala utvecklare:

• Använd BigInt för heltal större än 2⁵³ - 1: Närhelst din applikation kan hantera heltal större än `Number.MAX_SAFE_INTEGER`, använd BigInt för att garantera precision.
• Var explicit med typer: Kom ihåg att du inte kan blanda `BigInt` och `Number` i aritmetiska operationer. Utför alltid explicita konverteringar och var medveten om potentiell precisionsförlust när du konverterar ett stort BigInt tillbaka till ett Number.
• Bemästra JSON-hantering: Var beredd att hantera `TypeError` från `JSON.stringify()`. Implementera en robust serialiserings- och deserialiseringsstrategi med en `toJSON`-metod eller ett `replacer`/`reviver`-par.
• Välj rätt verktyg för jobbet: BigInt är endast för heltal. För godtycklig precision med decimaler förblir bibliotek som `Decimal.js` det lämpliga valet. Använd `Number` för alla andra beräkningar som inte är heltal eller som involverar små heltal för att bibehålla prestanda.

Genom att omfamna BigInt kan den internationella JavaScript-gemenskapen nu med självförtroende ta sig an utmaningar inom finans, vetenskap, dataintegritet och kryptografi, och därmed flytta fram gränserna för vad som är möjligt på webben och bortom den.