JavaScript BigInt: Kattava opas suurten lukujen laskentaan

Vuosien ajan JavaScript-kehittäjät kohtasivat hiljaisen mutta merkittävän rajoituksen: kielen luontaisen kyvyn käsitellä numeroita. Vaikka JavaScriptin Number-tyyppi soveltui täydellisesti arkipäiväisiin laskutoimituksiin, se horjui kohdatessaan todella massiivisia kokonaislukuja, joita vaaditaan esimerkiksi kryptografiassa, tieteellisessä laskennassa ja moderneissa datajärjestelmissä. Tämä johti kiertoteiden, kolmannen osapuolen kirjastojen ja hienovaraisten, vaikeasti jäljitettävien tarkkuusvirheiden maailmaan.

Se aikakausi on ohi. BigInt-tyypin esittely natiivina JavaScriptin primitiivityyppinä on mullistanut tavan, jolla työskentelemme suurten lukujen kanssa. Se tarjoaa vankan, ergonomisen ja tehokkaan tavan suorittaa mielivaltaisen tarkkuuden kokonaislukuaritmetiikkaa suoraan kielen sisällä.

Tämä kattava opas on tarkoitettu kehittäjille ympäri maailmaa. Sukellamme syvälle BigIntin "miksi, mitä ja miten" -kysymyksiin. Olitpa rakentamassa rahoitussovellusta, vuorovaikutuksessa lohkoketjun kanssa tai yksinkertaisesti yrittämässä ymmärtää, miksi suuri uniikki tunnuksesi API:sta käyttäytyy oudosti, tämä artikkeli antaa sinulle tiedot BigIntin hallitsemiseen.

Ongelma: JavaScriptin Number-tyypin rajat

Ennen kuin voimme arvostaa ratkaisua, meidän on ymmärrettävä ongelma täysin. JavaScriptillä on suurimman osan historiastaan ollut vain yksi numerotyyppi: Number-tyyppi. Konepellin alla se esitetään IEEE 754 -standardin mukaisena 64-bittisenä kaksoistarkkuuden liukulukuna. Tämä muoto on erinomainen laajojen arvoalueiden, mukaan lukien desimaalien, esittämiseen, mutta sillä on kriittinen rajoitus kokonaislukujen kohdalla.

Tapaa MAX_SAFE_INTEGER

Liukulukuesityksensä vuoksi on olemassa raja sille, kuinka suuri kokonaisluku voidaan esittää täydellisellä tarkkuudella. Tämä raja on esitetty vakion kautta: Number.MAX_SAFE_INTEGER.

Sen arvo on 2⁵³ - 1, mikä on 9,007,199,254,740,991. Kutsutaan sitä lyhyesti yhdeksäksi biljoonaksi.

Mitä tahansa kokonaislukua välillä -Number.MAX_SAFE_INTEGER - +Number.MAX_SAFE_INTEGER pidetään "turvallisena kokonaislukuna". Tämä tarkoittaa, että se voidaan esittää täsmälleen ja verrata oikein. Mutta mitä tapahtuu, kun astumme tämän alueen ulkopuolelle?

Katsotaanpa sitä toiminnassa:

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

// Lisätään siihen 1
console.log(maxSafe + 1);    // 9007199254740992 - Tämä näyttää oikealta

// Lisätään toinen 1
console.log(maxSafe + 2);    // 9007199254740992 - Oho. Väärä tulos.

// Tilanne pahenee
console.log(maxSafe + 3);    // 9007199254740994 - Hetkinen, mitä?
console.log(maxSafe + 4);    // 9007199254740996 - Se hyppii numeroiden yli!

// Myös yhtäsuuruuden tarkistus epäonnistuu
console.log(maxSafe + 1 === maxSafe + 2); // true - Tämä on matemaattisesti väärin!
            

              
                Copy
              
            
          

Kuten näet, kun ylitämme Number.MAX_SAFE_INTEGER -arvon, JavaScript ei voi enää taata laskelmiemme tarkkuutta. Numeroiden esitykseen alkaa tulla aukkoja, mikä johtaa pyöristysvirheisiin ja vääriin tuloksiin. Tämä on painajainen sovelluksille, jotka vaativat tarkkuutta suurten kokonaislukujen kanssa.

Vanhat kiertotavat

Vuosien ajan maailmanlaajuinen kehittäjäyhteisö turvautui ulkoisiin kirjastoihin tämän ongelman ratkaisemiseksi. Kirjastoista kuten bignumber.js, decimal.js ja long.js tuli vakiotyökaluja. Ne toimivat esittämällä suuria lukuja merkkijonoina tai numeroiden taulukkoina ja toteuttamalla aritmeettiset operaatiot ohjelmistollisesti.

Vaikka nämä kirjastot olivat tehokkaita, niillä oli kompromisseja:

• Suorituskyvyn heikkeneminen: Operaatiot olivat huomattavasti hitaampia kuin natiivit numerolaskelmat.
• Tiedostokoon kasvu: Ne lisäsivät painoa sovellusten paketteihin, mikä on huolenaihe verkkosuorituskyvyn kannalta.
• Erilainen syntaksi: Kehittäjien oli käytettävä oliometodeja (esim. a.add(b)) standardien aritmeettisten operaattoreiden (a + b) sijaan, mikä teki koodista vähemmän intuitiivista.

Esittelyssä BigInt: Natiivi ratkaisu

BigInt esiteltiin ES2020:ssa ratkaisemaan tämä ongelma natiivisti. BigInt on uusi primitiivityyppi JavaScriptissä, joka tarjoaa tavan esittää kokonaislukuja, jotka ovat suurempia kuin 2⁵³ - 1.

BigIntin keskeinen ominaisuus on, että sen koko ei ole kiinteä. Se voi esittää mielivaltaisen suuria kokonaislukuja, joita rajoittaa vain isäntäjärjestelmän käytettävissä oleva muisti. Tämä poistaa täysin ne tarkkuusongelmat, joita näimme Number-tyypin kanssa.

Kuinka luoda BigInt

On kaksi pääasiallista tapaa luoda BigInt:

1. Lisäämällä `n`-pääte kokonaislukuliteraaliin: Tämä on yksinkertaisin ja yleisin tapa.
2. Käyttämällä BigInt()-konstruktorifunktiota: Tämä on hyödyllistä, kun arvo muunnetaan toisesta tyypistä, kuten merkkijonosta tai numerosta.

Tässä miltä ne näyttävät koodissa:

            // 1. Käyttämällä 'n'-päätettä
const myFirstBigInt = 900719925474099199n;
const anotherBigInt = 123456789012345678901234567890n;

// 2. Käyttämällä BigInt()-konstruktoria
const fromString = BigInt("98765432109876543210");
const fromNumber = BigInt(100);

// Voit tarkistaa tyypin
console.log(typeof myFirstBigInt); // "bigint"
console.log(typeof 100);          // "number"
            

              
                Copy
              
            
          

BigIntin avulla aiemmin epäonnistunut laskutoimituksemme toimii nyt täydellisesti:

            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"

// Yhtäsuuruus toimii odotetusti
console.log(maxSafePlusOne === maxSafePlusTwo); // false
            

              
                Copy
              
            
          

Työskentely BigIntin kanssa: Syntaksi ja operaatiot

BigIntit käyttäytyvät paljolti kuten tavalliset numerot, mutta muutamalla ratkaisevalla erolla, jotka jokaisen kehittäjän on ymmärrettävä bugien välttämiseksi.

Aritmeettiset operaatiot

Kaikki standardit aritmeettiset operaattorit toimivat BigIntien kanssa:

• Yhteenlasku: +
• Vähennyslasku: -
• Kertolasku: *
• Potenssiin korotus: **
• Jakojäännös (Modulo): %

Ainoa operaattori, joka käyttäytyy eri lailla, on jakolasku (/).

            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
              
            
          

Jakolaskun varoitus

Koska BigIntit voivat esittää vain kokonaislukuja, jakolaskun tulos aina katkaistaan (murtolukuosa hylätään). Se ei pyöristä.

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

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

              
                Copy
              
            
          

Tämä on kriittinen ero. Jos sinun tarvitsee suorittaa laskelmia desimaaleilla, BigInt ei ole oikea työkalu. Sinun tulisi jatkaa Number-tyypin tai erillisen desimaalikirjaston käyttöä.

Vertailu ja yhtäsuuruus

Vertailuoperaattorit, kuten >, <, >= ja <=, toimivat saumattomasti BigIntien välillä ja jopa BigIntin ja Numberin välillä.

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

              
                Copy
              
            
          

Yhtäsuuruus on kuitenkin vivahteikkaampi ja yleinen sekaannuksen lähde.

• Löysä yhtäsuuruus (==): Tämä operaattori suorittaa tyyppipakotuksen. Se katsoo, että BigInt ja Number, joilla on sama matemaattinen arvo, ovat yhtä suuria.
• Tiukka yhtäsuuruus (===): Tämä operaattori ei suorita tyyppipakotusta. Koska BigInt ja Number ovat eri tyyppejä, se palauttaa aina false, kun niitä verrataan.

            console.log(10n == 10);  // true - Ole varovainen tämän kanssa!
console.log(10n === 10); // false - Suositeltavaa selkeyden vuoksi.

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

              
                Copy
              
            
          

Paras käytäntö: Välttääksesi hienovaraisia bugeja, käytä aina tiukkaa yhtäsuuruutta (===) ja ole selkeä vertailemistasi tyypeistä. Jos sinun on verrattava BigIntia ja Numberia, on usein selkeämpää muuntaa ensin toinen toiseksi, pitäen mielessä mahdollisen tarkkuuden menetyksen.

Tyyppien yhteensopimattomuus: Tiukka erottelu

JavaScript noudattaa tiukkaa sääntöä: et voi sekoittaa BigInt- ja Number-tyyppisiä operandeja useimmissa aritmeettisissa operaatioissa.

Tämän yrittäminen johtaa TypeError-virheeseen. Tämä on tarkoituksellinen suunnitteluvalinta estääkseen kehittäjiä vahingossa menettämästä tarkkuutta.

            const myBigInt = 100n;
const myNumber = 50;

try {
  const result = myBigInt + myNumber; // Tämä aiheuttaa virheen
} catch (error) {
  console.log(error); // TypeError: Cannot mix BigInt and other types, use explicit conversions
}
            

              
                Copy
              
            
          

Oikea lähestymistapa: Eksplisiittinen muunnos

Suorittaaksesi operaation BigIntin ja Numberin välillä, sinun on eksplisiittisesti muunnettava jompikumpi niistä.

            const myBigInt = 100n;
const myNumber = 50;

// Muunna Number BigIntiksi (turvallista)
const result1 = myBigInt + BigInt(myNumber);
console.log(result1); // 150n

// Muunna BigInt Numberiksi (mahdollisesti vaarallista!)
const veryLargeBigInt = 900719925474099199n;

// Tämä menettää tarkkuutta!
const unsafeNumber = Number(veryLargeBigInt);
console.log(unsafeNumber); // 900719925474099200 - Arvo on pyöristetty!

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

              
                Copy
              
            
          

Kriittinen sääntö: Muunna BigInt Numberiksi vain, jos olet täysin varma, että se mahtuu turvallisen kokonaisluvun alueelle. Muussa tapauksessa muunna aina Number BigIntiksi tarkkuuden säilyttämiseksi.

Käytännön käyttötapaukset BigIntille globaalissa kontekstissa

Tarve BigIntille ei ole abstrakti akateeminen ongelma. Se ratkaisee todellisia haasteita, joita kehittäjät kohtaavat eri kansainvälisillä aloilla.

1. Korkean tarkkuuden aikaleimat

JavaScriptin `Date.now()` palauttaa millisekuntien määrän Unix-epochin alusta. Vaikka tämä riittää monille verkkosovelluksille, se ei ole tarpeeksi tarkka korkean suorituskyvyn järjestelmille. Monet hajautetut järjestelmät, tietokannat ja lokituskehykset ympäri maailmaa käyttävät nanosekunnin tarkkuudella olevia aikaleimoja tapahtumien tarkkaan järjestämiseen. Nämä aikaleimat esitetään usein 64-bittisinä kokonaislukuina, jotka ovat liian suuria Number-tyypille.

            // Aikaleima korkean resoluution järjestelmästä (esim. nanosekunteina)
const nanoTimestampStr = "1670000000123456789";

// Number-tyypin käyttö johtaa tarkkuuden menetykseen
const lostPrecision = Number(nanoTimestampStr);
console.log(lostPrecision); // 1670000000123456800 - Virheellinen!

// BigInt säilyttää sen täydellisesti
const correctTimestamp = BigInt(nanoTimestampStr);
console.log(correctTimestamp.toString()); // "1670000000123456789"

// Voimme nyt suorittaa tarkkoja laskelmia
const oneSecondInNanos = 1_000_000_000n;
const nextSecond = correctTimestamp + oneSecondInNanos;
console.log(nextSecond.toString()); // "1670001000123456789"
            

              
                Copy
              
            
          

2. Uniikit tunnisteet (ID:t) API-rajapinnoista

Hyvin yleinen skenaario on vuorovaikutus API-rajapintojen kanssa, jotka käyttävät 64-bittisiä kokonaislukuja uniikkeina objektitunnisteina. Tämä on malli, jota käyttävät suuret globaalit alustat, kuten Twitter (Snowflake ID:t), ja monet tietokantajärjestelmät (esim. BIGINT-tyyppi SQL:ssä).

Kun haet dataa tällaisesta API:sta, selaimesi tai Node.js-ympäristösi JSON-jäsennin saattaa yrittää jäsentää tämän suuren ID:n Number-tyyppinä, mikä johtaa datan korruptoitumiseen jo ennen kuin ehdit käsitellä sitä.

            // Tyypillinen JSON-vastaus API:sta
// Huom: ID on suuri numero, ei merkkijono.
const jsonResponse = '{"id": 1367874743838343168, "text": "Hello, world!"}';

// Tavallinen JSON.parse korruptoi ID:n
const parsedData = JSON.parse(jsonResponse);
console.log(parsedData.id); // 1367874743838343200 - Väärä ID!

// Ratkaisu: Varmista, että API lähettää suuret ID:t merkkijonoina.
const safeJsonResponse = '{"id": "1367874743838343168", "text": "Hello, world!"}';

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

              
                Copy
              
            
          

Tästä syystä on laajalti hyväksytty paras käytäntö, että API-rajapinnat serialisoivat suuret kokonaislukutunnisteet merkkijonoiksi JSON-sisällössä varmistaakseen yhteensopivuuden kaikkien asiakkaiden kanssa.

3. Kryptografia

Moderni kryptografia rakentuu matematiikalle, joka sisältää erittäin suuria kokonaislukuja. Algoritmit, kuten RSA, perustuvat operaatioihin numeroilla, jotka ovat satoja tai jopa tuhansia bittejä pitkiä. BigInt mahdollistaa näiden laskelmien suorittamisen natiivisti JavaScriptissä, mikä on olennaista verkkopohjaisille kryptografisille sovelluksille, kuten niille, jotka käyttävät Web Crypto API:ta tai toteuttavat protokollia Node.js:ssä.

Vaikka täydellinen kryptografinen esimerkki on monimutkainen, voimme nähdä käsitteellisen demon:

            // Kaksi erittäin suurta alkulukua (vain demonstraatiotarkoituksessa)
const p = 1143400375533529n;
const q = 982451653n; // Pienempi esimerkkiä varten

// RSA:ssa ne kerrotaan keskenään moduulin saamiseksi
const n = p * q;
console.log(n.toString()); // "1123281328905333100311297"

// Tämä laskutoimitus olisi mahdoton Number-tyypillä.
// BigInt hoitaa sen vaivattomasti.
            

              
                Copy
              
            
          

4. Rahoitus- ja lohkoketjusovellukset

Rahoituksen, erityisesti kryptovaluuttojen, parissa työskennellessä tarkkuus on ensiarvoisen tärkeää. Monet kryptovaluutat, kuten Bitcoin, mittaavat arvoa pienimmässä yksikössään (esim. satoshit). Näiden yksiköiden kokonaismäärä voi helposti ylittää Number.MAX_SAFE_INTEGER -arvon. BigInt on täydellinen työkalu näiden suurten, tarkkojen määrien käsittelyyn turvautumatta liukulukuaritmetiikkaan, joka on altis pyöristysvirheille.

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

// Bitcoinien kokonaismäärä on 21 miljoonaa
const totalBTCSupply = 21_000_000n;

// Laske satoshien kokonaismäärä
const totalSatoshis = totalBTCSupply * satoshisPerBTC;

// 2 100 000 000 000 000 - Tämä on 2.1 biljoonaa
console.log(totalSatoshis.toString());

// Tämä arvo on suurempi kuin Number.MAX_SAFE_INTEGER
console.log(totalSatoshis > BigInt(Number.MAX_SAFE_INTEGER)); // true
            

              
                Copy
              
            
          

Edistyneet aiheet ja yleiset sudenkuopat

Serialisointi ja JSON.stringify()

Yksi yleisimmistä ongelmista, joita kehittäjät kohtaavat, on BigInt-arvoja sisältävien objektien serialisointi. Oletuksena JSON.stringify() ei osaa käsitellä bigint-tyyppiä ja aiheuttaa TypeError-virheen.

            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
              
            
          

Ratkaisu 1: Toteuta `toJSON`-metodi

Voit kertoa JSON.stringify-funktiolle, kuinka käsitellä BigInt-arvoja lisäämällä `toJSON`-metodin BigInt.prototype-prototyyppiin. Tämä lähestymistapa muokkaa globaalia prototyyppiä, mikä saattaa olla epätoivottavaa joissakin jaetuissa ympäristöissä, mutta se on erittäin tehokas.

            // Globaali muutos. Käytä harkiten.
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
              
            
          

Ratkaisu 2: Käytä korvaajafunktiota

Turvallisempi, paikallisempi lähestymistapa on käyttää `replacer`-argumenttia JSON.stringify-funktiossa. Tämä funktio kutsutaan jokaiselle avain/arvo-parille ja antaa sinun muuntaa arvon ennen serialisointia.

            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
              
            
          

Bittioperaatiot

BigInt tukee kaikkia bittioperaattoreita, jotka ovat tuttuja Number-tyypistä: & (AND), | (OR), ^ (XOR), ~ (NOT), << (vasen siirto) ja >> (etumerkin säilyttävä oikea siirto). Nämä ovat erityisen hyödyllisiä työskenneltäessä matalan tason dataformaattien, käyttöoikeuksien tai tietyntyyppisten algoritmien kanssa.

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

// Tarkista, onko lukuoikeus asetettu
console.log((permissions & READ_PERMISSION) > 0n); // true

// Tarkista, onko kirjoitusoikeus asetettu
console.log((permissions & WRITE_PERMISSION) > 0n); // false

// Lisää kirjoitusoikeus
const newPermissions = permissions | WRITE_PERMISSION;
console.log(newPermissions); // 7n (joka on 0111)
            

              
                Copy
              
            
          

Suorituskykyyn liittyviä huomioita

Vaikka BigInt on uskomattoman tehokas, on tärkeää ymmärtää sen suorituskykyominaisuudet:

• Number vs. BigInt: Turvallisen alueen sisällä oleville kokonaisluvuille tavalliset Number-operaatiot ovat huomattavasti nopeampia. Tämä johtuu siitä, että ne voidaan usein yhdistää suoraan konekielisiin käskyihin, joita tietokoneen prosessori käsittelee. BigInt-operaatiot, jotka ovat mielivaltaisen kokoisia, vaativat monimutkaisempia ohjelmistopohjaisia algoritmeja.
• BigInt vs. kirjastot: Natiivi BigInt on yleensä paljon nopeampi kuin JavaScript-pohjaiset suurten lukujen kirjastot. Toteutus on osa JavaScript-moottoria (kuten V8 tai SpiderMonkey) ja on kirjoitettu matalamman tason kielellä, kuten C++, mikä antaa sille merkittävän suorituskykyedun.

Kultainen sääntö: Käytä Number-tyyppiä kaikissa numeerisissa laskelmissa, ellet usko, että arvot saattavat ylittää Number.MAX_SAFE_INTEGER -arvon. Käytä BigInt-tyyppiä, kun tarvitset sen ominaisuuksia, ei oletusarvoisena korvikkeena kaikille numeroille.

Selaimen ja ympäristön yhteensopivuus

BigInt on moderni JavaScript-ominaisuus, mutta sen tuki on nyt laajalle levinnyt koko globaalissa ekosysteemissä.

• Verkkoselaimet: Tuettu kaikissa suurimmissa moderneissa selaimissa (Chrome 67+, Firefox 68+, Safari 14+, Edge 79+).
• Node.js: Tuettu versiosta 10.4.0 alkaen.

Projekteissa, joiden on tuettava hyvin vanhoja ympäristöjä, transpilaatio työkaluilla kuten Babel voi olla vaihtoehto, mutta tähän liittyy suorituskykyhaitta. Nykyisen laajan tuen ansiosta useimmat uudet projektit voivat käyttää BigIntia natiivisti ilman huolta.

Yhteenveto ja parhaat käytännöt

BigInt on tehokas ja olennainen lisä JavaScript-kieleen. Se tarjoaa natiivin, tehokkaan ja ergonomisen ratkaisun pitkäaikaiseen suurten kokonaislukujen aritmetiikan ongelmaan, mahdollistaen uudenlaisten sovellusten rakentamisen JavaScriptillä, aina kryptografiasta korkean tarkkuuden datankäsittelyyn.

Jotta voit käyttää sitä tehokkaasti ja välttää yleiset sudenkuopat, pidä nämä parhaat käytännöt mielessä:

1. Käytä `n`-päätettä: Suosi 123n-literaalisyntaksia BigInt-arvojen luomiseen. Se on selkeä, ytimekäs ja välttää mahdollisen tarkkuuden menetyksen luonnin aikana.
2. Älä sekoita tyyppejä: Muista, että et voi sekoittaa BigInt- ja Number-tyyppejä aritmeettisissa operaatioissa. Ole selkeä muunnoksissasi: BigInt() tai Number().
3. Priorisoi tarkkuus: Kun muunnat tyyppien välillä, suosi aina Number-tyypin muuntamista BigInt-tyypiksi estääksesi vahingossa tapahtuvan tarkkuuden menetyksen.
4. Käytä tiukkaa yhtäsuuruutta: Käytä ===-operaattoria ==-operaattorin sijaan vertailuissa välttääksesi tyyppipakotuksen aiheuttamaa hämmentävää käyttäytymistä.
5. Käsittele JSON-serialisointi: Suunnittele BigInt-arvojen serialisointi. Käytä mukautettua replacer-funktiota JSON.stringify-metodissa turvallisen, ei-globaalin ratkaisun aikaansaamiseksi.
6. Valitse oikea työkalu: Käytä Number-tyyppiä yleiskäyttöiseen matematiikkaan turvallisen kokonaislukualueen sisällä paremman suorituskyvyn saavuttamiseksi. Turvaudu BigInt-tyyppiin vain, kun todella tarvitset sen mielivaltaisen tarkkuuden ominaisuuksia.

Omaksumalla BigIntin ja ymmärtämällä sen säännöt, voit kirjoittaa vankempia, tarkempia ja tehokkaampia JavaScript-sovelluksia, jotka pystyvät vastaamaan minkä tahansa mittakaavan numeerisiin haasteisiin.