M

MLOG

Română

Un ghid complet pentru tipul BigInt din JavaScript, acoperind caracteristicile, utilizarea și aplicațiile sale în gestionarea aritmeticii numerelor întregi mari. Aflați cum să depășiți limitările JavaScript și să efectuați calcule complexe cu precizie.

JavaScript BigInt: Stăpânirea Aritmeticii Numerelor Întregi Mari

JavaScript, deși un limbaj versatil, are limitări atunci când lucrează cu numere întregi foarte mari. Tipul standard `Number` poate reprezenta cu acuratețe numere întregi doar până la o anumită limită, cunoscută sub numele de `Number.MAX_SAFE_INTEGER`. Dincolo de această limită, calculele devin imprecise, ducând la rezultate neașteptate. Aici intervine BigInt pentru a ne salva. Introdus în ECMAScript 2020, BigInt este un obiect încorporat care oferă o modalitate de a reprezenta și manipula numere întregi de dimensiuni arbitrare, depășind limitările tipului standard `Number`.

Înțelegerea Nevoii pentru BigInt

Înainte de BigInt, dezvoltatorii JavaScript trebuiau să se bazeze pe biblioteci sau implementări personalizate pentru a gestiona calculele cu numere întregi mari. Aceste soluții veneau adesea cu un cost de performanță și o complexitate sporită. Introducerea BigInt a oferit o modalitate nativă și eficientă de a lucra cu numere întregi mari, deschizând posibilități pentru aplicații în diverse domenii, inclusiv:

Crearea Valorilor BigInt

Există două modalități principale de a crea valori BigInt în JavaScript:

  1. Folosind constructorul `BigInt()`: Acest constructor poate converti o valoare numerică, un șir de caractere sau o valoare booleană într-un BigInt.
  2. Folosind sufixul `n`: Adăugarea lui `n` la un literal întreg creează un BigInt.

Exemple:

Folosind constructorul `BigInt()`:


const bigIntFromNumber = BigInt(12345678901234567890);
const bigIntFromString = BigInt("98765432109876543210");
const bigIntFromBoolean = BigInt(true); // Rezultă 1n
const bigIntFromFalseBoolean = BigInt(false); // Rezultă 0n

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

Folosind sufixul `n`:


const bigIntLiteral = 12345678901234567890n;
console.log(bigIntLiteral); // Afișare: 12345678901234567890n

Notă Importantă: Nu puteți amesteca direct valori BigInt și Number în operații aritmetice. Trebuie să le convertiți explicit la același tip înainte de a efectua calcule. Încercarea de a le amesteca direct va duce la o eroare de tip `TypeError`.

Operații Aritmetice cu BigInt

BigInt suportă majoritatea operatorilor aritmetici standard, inclusiv:

Exemple:


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

const sum = a + b;
const difference = a - b;
const product = a * b;
const quotient = a / 2n; // Notă: Împărțirea trunchiază către zero
const remainder = a % 7n;
const power = a ** 3n; // Exponențierea funcționează conform așteptărilor

console.log("Suma:", sum); // Afișare: Suma: 111111111011111111100n
console.log("Diferența:", difference); // Afișare: Diferența: -86419753208641975320n
console.log("Produsul:", product); // Afișare: Produsul: 1219326311370217957951669538098765432100n
console.log("Câtul:", quotient); // Afișare: Câtul: 6172839450617283945n
console.log("Restul:", remainder); // Afișare: Restul: 5n
console.log("Puterea:", power); // Afișare: Puterea: 187641281029182300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n

Considerații Importante:

Operatori de Comparație

Puteți utiliza operatorii de comparație standard (`==`, `!=`, `<`, `>`, `<=`, `>=`) pentru a compara valori BigInt cu alte valori BigInt sau chiar cu valori Number. Cu toate acestea, fiți atenți la potențiala conversie implicită de tip (type coercion).

Exemple:


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

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

console.log(a == c);   // Afișare: true (conversie implicită de tip)
console.log(a === c);  // Afișare: false (fără conversie implicită de tip)

Bună Practică: Folosiți egalitatea strictă (`===`) și inegalitatea strictă (`!==`) pentru a evita conversia implicită de tip neașteptată atunci când comparați valori BigInt și Number.

Conversia între BigInt și Number

Deși operațiile aritmetice directe între BigInt și Number nu sunt permise, puteți converti între cele două tipuri. Totuși, fiți conștienți de potențiala pierdere de precizie la conversia unui BigInt într-un Number dacă valoarea BigInt depășește `Number.MAX_SAFE_INTEGER`.

Exemple:


const bigIntValue = 9007199254740991n; // Number.MAX_SAFE_INTEGER
const numberValue = Number(bigIntValue); // Conversia BigInt la Number
console.log(numberValue); // Afișare: 9007199254740991

const largerBigIntValue = 9007199254740992n; // Depășește Number.MAX_SAFE_INTEGER
const largerNumberValue = Number(largerBigIntValue);
console.log(largerNumberValue); // Afișare: 9007199254740992 (poate fi imprecis)

const numberToBigInt = BigInt(12345); // Conversia Number la BigInt
console.log(numberToBigInt); // Afișare: 12345n

Cazuri de Utilizare și Exemple

Criptografie

Algoritmii criptografici se bazează adesea pe numere prime foarte mari pentru securitate. BigInt oferă o modalitate de a reprezenta și manipula eficient aceste numere.


// Exemplu: Generarea unei perechi de chei simple (nesigure)
function generateKeyPair() {
  const p = 281n; // Un număr prim
  const q = 283n; // Un alt număr prim
  const n = p * q; // Modulul
  const totient = (p - 1n) * (q - 1n); // Funcția totient a lui Euler

  // Alegeți un e (exponent public) astfel încât 1 < e < totient și cmmdc(e, totient) = 1
  const e = 17n;

  // Calculați d (exponent privat) astfel încât (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("Cheie Publică:", keyPair.publicKey);
console.log("Cheie Privată:", keyPair.privateKey);

Notă: Acesta este un exemplu simplificat doar în scop demonstrativ. Criptografia din lumea reală folosește numere prime mult mai mari și algoritmi mai sofisticați.

Calcule Financiare

Când se lucrează cu sume mari de bani, în special în tranzacții internaționale, precizia este critică. BigInt poate preveni erorile de rotunjire și poate asigura calcule exacte.


// Exemplu: Calcularea dobânzii compuse
function calculateCompoundInterest(principal, rate, time) {
  const principalBigInt = BigInt(principal * 100); // Convertire în cenți
  const rateBigInt = BigInt(rate * 10000);       // Convertire în zecimi de miimi de procent
  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 USD
const rate = 0.05;    // rată a dobânzii de 5%
const time = 10;     // 10 ani

const finalAmount = calculateCompoundInterest(principal, rate, time);
console.log("Suma Finală:", finalAmount); // Afișare: Suma Finală: 1628894.6267774413 (aproximativ)

În acest exemplu, convertim principalul și rata la valori BigInt pentru a evita erorile de rotunjire în timpul calculului. Rezultatul este apoi convertit înapoi la un Number pentru afișare.

Lucrul cu ID-uri Mari

În sistemele distribuite, generarea de ID-uri unice pe mai multe servere poate fi o provocare. Utilizarea BigInt vă permite să creați ID-uri foarte mari care au o probabilitate redusă de a intra în coliziune.


// Exemplu: Generarea unui ID unic bazat pe timestamp și ID-ul serverului
function generateUniqueId(serverId) {
  const timestamp = BigInt(Date.now());
  const serverIdBigInt = BigInt(serverId);
  const random = BigInt(Math.floor(Math.random() * 1000)); // Adăugați puțină aleatorietate

  // Combinați valorile pentru a crea un ID unic
  const uniqueId = (timestamp << 20n) + (serverIdBigInt << 10n) + random;
  return uniqueId.toString(); // Returnați ca șir de caractere pentru o manipulare ușoară
}

const serverId = 123; // Exemplu de ID de server
const id1 = generateUniqueId(serverId);
const id2 = generateUniqueId(serverId);

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

BigInt și JSON

Valorile BigInt nu sunt suportate nativ de JSON. Încercarea de a serializa un obiect JavaScript care conține un BigInt folosind `JSON.stringify()` va duce la o eroare de tip `TypeError`. Pentru a gestiona valorile BigInt atunci când lucrați cu JSON, aveți câteva opțiuni:

  1. Conversia la Șir de Caractere: Convertiți BigInt-ul la un șir de caractere înainte de serializare. Aceasta este cea mai comună și directă abordare.
  2. Serializare/Deserializare Personalizată: Utilizați o funcție personalizată de serializare/deserializare pentru a gestiona valorile BigInt.

Exemple:

Conversia la Șir de Caractere:


const data = {
  id: 12345678901234567890n,
  name: "Example Data",
};

// Convertiți BigInt la șir de caractere înainte de serializare
data.id = data.id.toString();

const jsonData = JSON.stringify(data);
console.log(jsonData); // Afișare: {"id":"12345678901234567890","name":"Example Data"}

// La deserializare, va trebui să convertiți șirul înapoi la un BigInt
const parsedData = JSON.parse(jsonData, (key, value) => {
  if (key === "id") {
    return BigInt(value);
  }
  return value;
});

console.log(parsedData.id); // Afișare: 12345678901234567890n

Serializare/Deserializare Personalizată (folosind `replacer` și `reviver`):


const data = {
  id: 12345678901234567890n,
  name: "Example Data",
};

// Serializare personalizată
const jsonData = JSON.stringify(data, (key, value) => {
  if (typeof value === 'bigint') {
    return value.toString();
  } else {
    return value;
  }
});

console.log(jsonData);

// Deserializare personalizată
const parsedData = JSON.parse(jsonData, (key, value) => {
    if (typeof value === 'string' && /^[0-9]+$/.test(value)) { //verificați dacă este un număr și un șir de caractere
      try {
        return BigInt(value);
      } catch(e) {
          return value;
      }
    }
    return value;
});

console.log(parsedData.id);

Compatibilitate cu Browserele

BigInt este larg suportat în browserele moderne. Cu toate acestea, este esențial să verificați compatibilitatea pentru browserele sau mediile mai vechi. Puteți utiliza un instrument precum Can I use pentru a verifica suportul browserelor. Dacă trebuie să suportați browsere mai vechi, ați putea lua în considerare utilizarea unui polyfill, dar fiți conștienți că polyfill-urile pot afecta performanța.

Considerații de Performanță

Deși BigInt oferă o modalitate puternică de a lucra cu numere întregi mari, este important să fiți conștienți de posibilele implicații de performanță.

Prin urmare, utilizați BigInt doar atunci când este necesar și optimizați-vă codul pentru performanță dacă efectuați un număr mare de operații cu BigInt.

Concluzie

BigInt este o adăugare valoroasă la JavaScript, permițând dezvoltatorilor să gestioneze aritmetica numerelor întregi mari cu precizie. Înțelegând caracteristicile, limitările și cazurile sale de utilizare, puteți folosi BigInt pentru a construi aplicații robuste și precise în diverse domenii, inclusiv criptografie, calcule financiare și calcul științific. Amintiți-vă să luați în considerare compatibilitatea cu browserele și implicațiile de performanță atunci când utilizați BigInt în proiectele dumneavoastră.

Explorare Suplimentară

Acest ghid oferă o imagine de ansamblu cuprinzătoare a BigInt în JavaScript. Explorați resursele din link-uri pentru informații mai detaliate și tehnici avansate.