JavaScript - BigInt: Gestione di Numeri veramente Grandi

Ciao a tutti, aspiranti programmatori! Oggi ci imbarchiamo in un viaggio emozionante nel mondo dei numeri veramente, veramente grandi in JavaScript. Prendete il volo, perché stiamo per esplorare il fascinante regno del BigInt!

Cos'è BigInt?

Immagina di contare le stelle nel cielo notturno. Conti e conti, ma improvvisamente il tuo calcolatore dice "Infinity". Frustrante, vero? Ecco dove BigInt entra in soccorso!

BigInt è un tipo numerico speciale in JavaScript che può rappresentare interi di lunghezza arbitraria. A differenza dei numeri normali, che hanno limitazioni, BigInt può gestire numeri quanto la tua immaginazione (o la memoria del tuo computer) lo permette.

Perché abbiamo bisogno di BigInt?

In JavaScript, i numeri normali sono memorizzati in 64 bit, il che significa che hanno un valore massimo sicuro di 9,007,199,254,740,991. È un numero grande, ma nel mondo dell'informatica, a volte abbiamo bisogno di andare anche oltre!

Vediamo cosa succede quando proviamo a superare questo limite:

console.log(9007199254740991n + 1n); // 9007199254740992n
console.log(9007199254740991n + 2n); // 9007199254740992n (Oops! Stesso risultato)

Come puoi vedere, JavaScript non può rappresentare accuratamente numeri oltre questo limite. Ecco dove BigInt si distingue!

Dichiarazione e Inizializzazione

Creare un BigInt è un gioco da ragazzi. Hai due opzioni:

1. Aggiungi 'n' alla fine di un intero
2. Usa la funzione BigInt()

Proviamo entrambi:

const bigNumber1 = 1234567890123456789012345678901234567890n;
const bigNumber2 = BigInt("9007199254740991");

console.log(bigNumber1); // 1234567890123456789012345678901234567890n
console.log(bigNumber2); // 9007199254740991n

Noti la 'n' alla fine? Questo è come JavaScript sa che è un BigInt!

Operazioni di Base

Ora che abbiamo i nostri numeri grandi, facciamo un po' di matematica!

const a = 1234567890n;
const b = 9876543210n;

console.log(a + b);  // 11111111100n
console.log(a - b);  // -8641975320n
console.log(a * b);  // 12193263111263526900n
console.log(a / b);  // 0n (Divisione intera)
console.log(a % b);  // 1234567890n

Ricorda, i BigInt sono sempre numeri interi. Quando si divide, il risultato è arrotondato al numero intero più vicino.

Confronto

Confrontare i BigInt è lo stesso di confrontare i numeri normali:

console.log(5n > 4n);   // true
console.log(5n < 4n);   // false
console.log(5n === 5);  // false (tipi diversi)
console.log(5n == 5);   // true (coercizione di tipo)

Notare le ultime due righe. I BigInt e i numeri normali sono considerati uguali quando si usa ==, ma non quando si usa ===. Questo perché === verifica sia il valore che il tipo di uguaglianza.

Conversioni

A volte avrai bisogno di convertire tra BigInt e numeri normali. Ecco come fare:

const bigNum = 123456789n;
const regularNum = Number(bigNum);

console.log(regularNum);  // 123456789

const backToBigInt = BigInt(regularNum);
console.log(backToBigInt);  // 123456789n

Attenzione quando converti i BigInt grandi in numeri normali, potresti perdere la precisione!

Esempi

Mettiamo le nostre conoscenze di BigInt in uso con alcuni esempi reali:

1. Calcolo dei Fattoriali

function factorial(n) {
if (n === 0n) return 1n;
return n * factorial(n - 1n);
}

console.log(factorial(20n));  // 2432902008176640000n

Questa funzione può calcolare fattoriali di numeri molto più grandi rispetto a quelli possibili con i numeri normali di JavaScript!

2. Lavorare con Numeri Primi veramente Grandi

function isPrime(n) {
if (n <= 1n) return false;
for (let i = 2n; i * i <= n; i++) {
if (n % i === 0n) return false;
}
return true;
}

const largeNumber = 2n ** 100n - 1n;
console.log(isPrime(largeNumber) ? "Primo" : "Non Primo");  // Non Primo

Questa funzione può controllare la primalità per numeri molto al di là dei limiti dei numeri normali di JavaScript!

Gestione degli Errori con BigInt

Quando si lavora con BigInt, ci sono alcune cose da tenere d'occhio:

try {
const result = 1n + 1;  // Questo genererà un errore
} catch (error) {
console.log("Errore:", error.message);  // Non si possono mescolare BigInt e altri tipi
}

try {
const result = Math.sqrt(4n);  // Questo genererà anche un errore
} catch (error) {
console.log("Errore:", error.message);  // Non si può convertire un valore BigInt in un numero
}

Ricorda, i BigInt possono solo essere usati con altri BigInt per operazioni aritmetiche, e molte funzioni Math non supportano i BigInt.

Metodi BigInt

Ecco una tabella dei metodi BigInt più comuni:

Metodo	Descrizione	Esempio
BigInt()	Crea un valore BigInt	BigInt(123)
BigInt.asIntN()	Avvolge un valore BigInt in un intero segnalato tra -2^(n-1) e 2^(n-1)-1	BigInt.asIntN(3, 5n) // 5n
BigInt.asUintN()	Avvolge un valore BigInt in un intero non segnalato tra 0 e 2^n-1	BigInt.asUintN(3, 5n) // 5n
BigInt.prototype.toString()	Restituisce una rappresentazione stringa di un valore BigInt	(123n).toString() // "123"
BigInt.prototype.valueOf()	Restituisce il valore primitivo di un oggetto BigInt	Object(123n).valueOf() // 123n

Ecco fatto, gente! Ora sei equipaggiato per gestire numeri più grandi delle stelle nel cielo. Ricorda, con grandi poteri arriva grande responsabilità - usa i tuoi BigInt saggiamente!

Buon coding, e possa i tuoi numeri essere sempre grandi quanto i tuoi sogni!

Credits: Image by storyset