M

MLOG

Magyar

Átfogó útmutató a JavaScript BigInt típusához, bemutatva annak jellemzőit, használatát és alkalmazásait a nagyméretű egész számok kezelésében. Tanulja meg, hogyan küzdje le a JavaScript korlátait, és végezzen bonyolult számításokat precízen.

JavaScript BigInt: A nagyméretű egész számok aritmetikájának elsajátítása

A JavaScript, bár egy sokoldalú nyelv, korlátokkal rendelkezik a nagyon nagy egész számok kezelése terén. A standard `Number` típus csak egy bizonyos határig, a `Number.MAX_SAFE_INTEGER`-ig képes pontosan reprezentálni az egész számokat. Ezen a határon túl a számítások pontatlanná válnak, ami váratlan eredményekhez vezethet. Itt jön a képbe a BigInt. Az ECMAScript 2020-ban bevezetett BigInt egy beépített objektum, amely lehetővé teszi tetszőleges méretű egész számok reprezentálását és manipulálását, túllépve a standard `Number` típus korlátait.

A BigInt szükségességének megértése

A BigInt előtt a JavaScript fejlesztőknek könyvtárakra vagy egyedi implementációkra kellett támaszkodniuk a nagyméretű egész számokkal végzett számításokhoz. Ezek a megoldások gyakran teljesítménybeli többletterheléssel és megnövekedett bonyolultsággal jártak. A BigInt bevezetése natív és hatékony módot biztosított a nagy egész számokkal való munkára, lehetőségeket nyitva különböző területeken, többek között:

BigInt értékek létrehozása

Két fő módja van a BigInt értékek létrehozásának JavaScriptben:

  1. A `BigInt()` konstruktor használata: Ez a konstruktor egy számot, karakterláncot vagy logikai értéket tud BigInt-té alakítani.
  2. Az `n` utótag használata: Egy egész szám literálhoz `n`-et fűzve BigInt-et hoz létre.

Példák:

A `BigInt()` konstruktor használata:


const bigIntFromNumber = BigInt(12345678901234567890);
const bigIntFromString = BigInt("98765432109876543210");
const bigIntFromBoolean = BigInt(true); // Eredménye 1n
const bigIntFromFalseBoolean = BigInt(false); // Eredménye 0n

console.log(bigIntFromNumber); // Kimenet: 12345678901234567890n
console.log(bigIntFromString); // Kimenet: 98765432109876543210n
console.log(bigIntFromBoolean); // Kimenet: 1n
console.log(bigIntFromFalseBoolean); // Kimenet: 0n

Az `n` utótag használata:


const bigIntLiteral = 12345678901234567890n;
console.log(bigIntLiteral); // Kimenet: 12345678901234567890n

Fontos megjegyzés: A BigInt és Number értékeket nem lehet közvetlenül keverni aritmetikai műveletekben. A számítások elvégzése előtt explicit módon ugyanarra a típusra kell konvertálni őket. A közvetlen keverésük `TypeError`-t eredményez.

BigInt aritmetikai műveletek

A BigInt támogatja a legtöbb standard aritmetikai operátort, beleértve:

Példák:


const a = 12345678901234567890n;
const b = 98765432109876543210n;

const sum = a + b;
const difference = a - b;
const product = a * b;
const quotient = a / 2n; // Megjegyzés: Az osztás a nulla felé csonkít
const remainder = a % 7n;
const power = a ** 3n; // A hatványozás a várt módon működik

console.log("Összeg:", sum); // Kimenet: Összeg: 111111111011111111100n
console.log("Különbség:", difference); // Kimenet: Különbség: -86419753208641975320n
console.log("Szorzat:", product); // Kimenet: Szorzat: 1219326311370217957951669538098765432100n
console.log("Hányados:", quotient); // Kimenet: Hányados: 6172839450617283945n
console.log("Maradék:", remainder); // Kimenet: Maradék: 5n
console.log("Hatvány:", power); // Kimenet: Hatvány: 187641281029182300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n

Fontos szempontok:

Összehasonlító operátorok

Használhat standard összehasonlító operátorokat (`==`, `!=`, `<`, `>`, `<=`, `>=`) a BigInt értékek más BigInt vagy akár Number értékekkel való összehasonlítására. Azonban legyen óvatos a lehetséges típuskényszerítéssel.

Példák:


const a = 10n;
const b = 20n;
const c = 10;

console.log(a == b);   // Kimenet: false
console.log(a != b);   // Kimenet: true
console.log(a < b);    // Kimenet: true
console.log(a > b);    // Kimenet: false
console.log(a <= b);   // Kimenet: true
console.log(a >= b);   // Kimenet: false

console.log(a == c);   // Kimenet: true (típuskényszerítés)
console.log(a === c);  // Kimenet: false (nincs típuskényszerítés)

Bevált gyakorlat: Használjon szigorú egyenlőséget (`===`) és szigorú nemegyenlőséget (`!==`) a váratlan típuskényszerítés elkerülése érdekében, amikor BigInt és Number értékeket hasonlít össze.

Konverzió a BigInt és a Number között

Bár a közvetlen aritmetikai műveletek a BigInt és Number között nem megengedettek, konvertálhat a két típus között. Azonban legyen tisztában a pontosságvesztés lehetőségével, amikor egy BigInt-et Number-ré alakít, ha a BigInt értéke meghaladja a `Number.MAX_SAFE_INTEGER`-t.

Példák:


const bigIntValue = 9007199254740991n; // Number.MAX_SAFE_INTEGER
const numberValue = Number(bigIntValue); // BigInt konvertálása Number-ré
console.log(numberValue); // Kimenet: 9007199254740991

const largerBigIntValue = 9007199254740992n; // Meghaladja a Number.MAX_SAFE_INTEGER-t
const largerNumberValue = Number(largerBigIntValue);
console.log(largerNumberValue); // Kimenet: 9007199254740992 (pontatlan lehet)

const numberToBigInt = BigInt(12345); // Number konvertálása BigInt-té
console.log(numberToBigInt); // Kimenet: 12345n

Felhasználási esetek és példák

Kriptográfia

A kriptográfiai algoritmusok gyakran nagyon nagy prímszámokra támaszkodnak a biztonság érdekében. A BigInt lehetővé teszi ezeknek a számoknak a hatékony reprezentálását és manipulálását.


// Példa: Egy egyszerű (nem biztonságos) kulcspár generálása
function generateKeyPair() {
  const p = 281n; // Egy prímszám
  const q = 283n; // Egy másik prímszám
  const n = p * q; // Modulus
  const totient = (p - 1n) * (q - 1n); // Euler-féle totiens függvény

  // Válasszunk egy e-t (publikus kitevő), úgy hogy 1 < e < totient és gcd(e, totient) = 1
  const e = 17n;

  // Számítsuk ki a d-t (privát kitevő), úgy hogy (d * e) % totient = 1
  let d = 0n;
  for (let i = 1n; i < totient; i++) {
    if ((i * e) % totient === 1n) {
      d = i;
      break;
    }
  }

  return {
    publicKey: { n, e },
    privateKey: { n, d },
  };
}

const keyPair = generateKeyPair();
console.log("Publikus kulcs:", keyPair.publicKey);
console.log("Privát kulcs:", keyPair.privateKey);

Megjegyzés: Ez csak egy egyszerűsített példa demonstrációs célokra. A valós kriptográfia sokkal nagyobb prímszámokat és kifinomultabb algoritmusokat használ.

Pénzügyi számítások

Nagy pénzösszegek kezelésekor, különösen nemzetközi tranzakciók esetén, a pontosság kritikus. A BigInt megakadályozhatja a kerekítési hibákat és biztosíthatja a pontos számításokat.


// Példa: Kamatos kamat számítása
function calculateCompoundInterest(principal, rate, time) {
  const principalBigInt = BigInt(principal * 100); // Átváltás centekre
  const rateBigInt = BigInt(rate * 10000);       // Átváltás tízezred százalékra
  const timeBigInt = BigInt(time);

  let amount = principalBigInt;
  for (let i = 0n; i < timeBigInt; i++) {
    amount = amount * (10000n + rateBigInt) / 10000n;
  }

  const amountInDollars = Number(amount) / 100;
  return amountInDollars;
}

const principal = 1000000; // $1,000,000
const rate = 0.05;    // 5% kamatláb
const time = 10;     // 10 év

const finalAmount = calculateCompoundInterest(principal, rate, time);
console.log("Végösszeg:", finalAmount); // Kimenet: Végösszeg: 1628894.6267774413 (hozzávetőlegesen)

Ebben a példában a tőkét és a kamatlábat BigInt értékekké alakítjuk, hogy elkerüljük a kerekítési hibákat a számítás során. Az eredményt ezután visszakonvertáljuk Number-ré a megjelenítéshez.

Nagy azonosítókkal való munka

Elosztott rendszerekben az egyedi azonosítók generálása több szerveren keresztül kihívást jelenthet. A BigInt használata lehetővé teszi nagyon nagy azonosítók létrehozását, amelyek valószínűtlen, hogy ütköznek.


// Példa: Egyedi azonosító generálása időbélyeg és szerverazonosító alapján
function generateUniqueId(serverId) {
  const timestamp = BigInt(Date.now());
  const serverIdBigInt = BigInt(serverId);
  const random = BigInt(Math.floor(Math.random() * 1000)); // Adunk hozzá egy kis véletlenszerűséget

  // Az értékek kombinálása egyedi azonosító létrehozásához
  const uniqueId = (timestamp << 20n) + (serverIdBigInt << 10n) + random;
  return uniqueId.toString(); // Visszaadás karakterláncként a könnyebb kezelés érdekében
}

const serverId = 123; // Példa szerverazonosító
const id1 = generateUniqueId(serverId);
const id2 = generateUniqueId(serverId);

console.log("Egyedi ID 1:", id1);
console.log("Egyedi ID 2:", id2);

BigInt és JSON

A BigInt értékeket a JSON natívan nem támogatja. Ha egy BigInt-et tartalmazó JavaScript objektumot próbálunk szerializálni a `JSON.stringify()` segítségével, az `TypeError`-t eredményez. A BigInt értékek kezelésére JSON-nal való munka során két lehetőség van:

  1. Karakterlánccá alakítás: Alakítsa a BigInt-et karakterlánccá a szerializálás előtt. Ez a leggyakoribb és legegyszerűbb megközelítés.
  2. Egyedi szerializálás/deszerializálás: Használjon egyedi szerializáló/deszerializáló függvényt a BigInt értékek kezelésére.

Példák:

Karakterlánccá alakítás:


const data = {
  id: 12345678901234567890n,
  name: "Példa Adat",
};

// A BigInt karakterlánccá alakítása a szerializálás előtt
data.id = data.id.toString();

const jsonData = JSON.stringify(data);
console.log(jsonData); // Kimenet: {"id":"12345678901234567890","name":"Példa Adat"}

// Deszerializáláskor a karakterláncot vissza kell alakítani BigInt-té
const parsedData = JSON.parse(jsonData, (key, value) => {
  if (key === "id") {
    return BigInt(value);
  }
  return value;
});

console.log(parsedData.id); // Kimenet: 12345678901234567890n

Egyedi szerializálás/deszerializálás (a `replacer` és `reviver` használatával):


const data = {
  id: 12345678901234567890n,
  name: "Példa Adat",
};

// Egyedi szerializálás
const jsonData = JSON.stringify(data, (key, value) => {
  if (typeof value === 'bigint') {
    return value.toString();
  } else {
    return value;
  }
});

console.log(jsonData);

// Egyedi deszerializálás
const parsedData = JSON.parse(jsonData, (key, value) => {
    if (typeof value === 'string' && /^[0-9]+$/.test(value)) { //ellenőrizzük, hogy ez egy szám és egy karakterlánc-e
      try {
        return BigInt(value);
      } catch(e) {
          return value;
      }
    }
    return value;
});

console.log(parsedData.id);

Böngészőkompatibilitás

A BigInt széles körben támogatott a modern böngészőkben. Azonban elengedhetetlen ellenőrizni a kompatibilitást régebbi böngészők vagy környezetek esetében. Használhat egy olyan eszközt, mint a Can I use a böngészőtámogatás ellenőrzéséhez. Ha régebbi böngészőket is támogatnia kell, érdemes lehet egy polyfillt használni, de vegye figyelembe, hogy a polyfillek befolyásolhatják a teljesítményt.

Teljesítménybeli megfontolások

Bár a BigInt hatékony módot kínál a nagy egész számokkal való munkára, fontos tisztában lenni a lehetséges teljesítménybeli következményekkel.

Ezért a BigInt-et csak akkor használja, ha szükséges, és optimalizálja a kódját a teljesítmény érdekében, ha nagy számú BigInt műveletet végez.

Következtetés

A BigInt értékes kiegészítése a JavaScriptnek, lehetővé téve a fejlesztők számára, hogy precízen kezeljék a nagyméretű egész számok aritmetikáját. Jellemzőinek, korlátainak és felhasználási eseteinek megértésével kihasználhatja a BigInt-et robusztus és pontos alkalmazások készítéséhez különböző területeken, beleértve a kriptográfiát, a pénzügyi számításokat és a tudományos számítástechnikát. Ne felejtse el figyelembe venni a böngészőkompatibilitást és a teljesítménybeli következményeket, amikor BigInt-et használ a projektjeiben.

További források

Ez az útmutató átfogó áttekintést nyújt a JavaScript BigInt-jéről. Fedezze fel a linkelt forrásokat a részletesebb információkért és a haladó technikákért.