Numeri e BigInt in JavaScript: precisione e interi grandi

Un solo tipo per (quasi) tutti i numeri

La maggior parte dei linguaggi ti dà tipi separati per interi e decimali. JavaScript, storicamente, te ne dava uno solo: Number. Che scrivessi 42, 3.14 o -0.001, ottenevi sempre lo stesso primitivo, un numero in virgola mobile a doppia precisione a 64 bit secondo lo standard IEEE 754.

console.log(typeof 42);         // "number"
console.log(typeof 3.14);       // "number"
console.log(typeof -0.001);     // "number"
console.log(typeof NaN);        // "number"
console.log(typeof Infinity);   // "number"

È comodo: niente conversioni tra int e float, niente overflow a 2^31. Ma la rappresentazione in virgola mobile ha delle conseguenze, e colgono spesso di sorpresa chi inizia. Nel 2020 è stato aggiunto un secondo tipo numerico, BigInt, proprio per i casi in cui Number non basta.

La sorpresa della virgola mobile

Esegui questo:

console.log(0.1 + 0.2);
console.log(0.1 + 0.2 === 0.3);

La prima riga stampa 0.30000000000000004. La seconda stampa false. Non è una stranezza di JavaScript: Python, Java, C e qualsiasi linguaggio che usa numeri in virgola mobile IEEE 754 si comporta allo stesso modo.

Il motivo: 0.1 e 0.2 non si possono rappresentare in modo esatto in binario, proprio come 1/3 non si può scrivere in modo esatto in decimale. Viene salvata l'approssimazione binaria più vicina, e i piccoli errori si accumulano. Il modello mentale giusto è questo: tratta i valori Number con decimali come approssimazioni che per caso sono molto vicine a quello che hai scritto.

Per il denaro, non salvare $19.99 come 19.99. Salva i centesimi come interi, 1999, e formattali quando li mostri. È l'abitudine migliore in assoluto per evitare i bug della virgola mobile.

Confrontare numeri decimali in sicurezza

Visto che l'uguaglianza non è affidabile, quando serve confronta con una tolleranza:

const a = 0.1 + 0.2;
const b = 0.3;

const EPSILON = Number.EPSILON;
console.log(Math.abs(a - b) < EPSILON);  // true

Number.EPSILON è la differenza più piccola tra 1 e il numero rappresentabile successivo: una tolleranza predefinita ragionevole per valori vicini a 1. Per grandezze molto grandi o molto piccole ti servirà una tolleranza che si adatti alla scala dei valori.

L'intervallo degli interi sicuri in JavaScript

Gli interi fino a una certa dimensione sono esatti in un numero in virgola mobile a 64 bit. Oltre quella soglia inizi a perdere precisione un bit alla volta:

console.log(Number.MAX_SAFE_INTEGER);       // 9007199254740991
console.log(Number.MAX_SAFE_INTEGER + 1);   // 9007199254740992
console.log(Number.MAX_SAFE_INTEGER + 2);   // 9007199254740992  (!)

console.log(Number.isSafeInteger(9007199254740991));  // true
console.log(Number.isSafeInteger(9007199254740993));  // false

2^53 - 1 è l'ultimo intero per cui tutti gli interi più piccoli sono rappresentabili. Oltre quel punto, alcuni interi semplicemente non esistono nel tipo Number: vengono arrotondati al vicino più prossimo. È un bug silenzioso di corruzione dei dati pronto a scattare se leggi ID a 64 bit da un database come normali numeri JSON.

Arriva BigInt

BigInt è un primitivo a parte per interi a precisione arbitraria. Ne crei uno aggiungendo n a un letterale intero, oppure chiamando BigInt(...):

const a = 9007199254740993n;
const b = BigInt("9007199254740993");
const c = BigInt(42);

console.log(a);           // 9007199254740993n
console.log(typeof a);    // "bigint"
console.log(a === b);     // true

I BigInt non hanno altro limite superiore che la memoria disponibile. Sono lo strumento giusto per:

• ID di database o snowflake ID di Twitter/X che superano 2^53.
• Calcoli crittografici.
• Qualsiasi aritmetica intera in cui risultati esatti contano più della velocità pura.

Non sono invece lo strumento giusto per i contatori di tutti i giorni, gli indici degli array o il denaro in centesimi: il normale Number è più veloce e funziona con tutte le API del linguaggio.

Aritmetica con BigInt

Tutti gli operatori abituali funzionano, a patto che entrambi gli operandi siano BigInt:

const big = 10n ** 30n;
console.log(big);                 // 1000000000000000000000000000000n
console.log(big + 1n);            // 1000000000000000000000000000001n
console.log(big * 2n);            // 2000000000000000000000000000000n

console.log(7n / 2n);             // 3n  (integer division, truncated)
console.log(7n % 2n);             // 1n

La divisione tronca verso lo zero: non esistono BigInt frazionari. Se ti serve una frazione, torni nel territorio di Number (o di una libreria decimale).

Non mescolare i tipi

La regola su cui tutti inciampano: non puoi mescolare Number e BigInt nella stessa espressione.

try {
    console.log(1n + 1);
} catch (err) {
    console.log(err.message);
}

// Convert explicitly:
console.log(1n + BigInt(1));      // 2n
console.log(Number(1n) + 1);      // 2

Il confronto è l'unica eccezione: <, > e == fanno la coercizione tra i due tipi:

console.log(1n < 2);       // true
console.log(1n == 1);      // true
console.log(1n === 1);     // false  (different types)

Quindi == li considera uguali, === no. Se usi già === ovunque (e dovresti), considera i confronti numerici tra i due tipi un campanello d'allarme nel design: scegli un lato e converti.

Convertire tra number e bigint

Due conversioni, due trappole:

// Number -> BigInt: must be a safe integer, no decimals
console.log(BigInt(42));          // 42n
try { BigInt(3.14); } catch (e) { console.log(e.message); }

// BigInt -> Number: may lose precision
const huge = 9007199254740993n;
console.log(Number(huge));        // 9007199254740992  (!)

Passare da Number a BigInt è rigido: decimali e NaN lanciano un errore. Passare da BigInt a Number è permissivo ma perde precisione: tutto ciò che supera MAX_SAFE_INTEGER viene arrotondato. Se stai convertendo un BigInt ricevuto da un server, chiediti prima se ti serve davvero.

Valori speciali del tipo Number

Già che ci siamo, ci sono tre valori del tipo Number che non sono numeri in senso matematico:

console.log(1 / 0);              // Infinity
console.log(-1 / 0);             // -Infinity
console.log(0 / 0);              // NaN
console.log("abc" - 1);          // NaN

console.log(NaN === NaN);        // false  (!)
console.log(Number.isNaN(NaN));  // true

Infinity e -Infinity compaiono quando dividi per zero o superi l'intervallo dei numeri in virgola mobile. NaN ("not a number") compare quando un'operazione aritmetica non produce un risultato sensato.

NaN è famoso per non essere uguale a sé stesso: fa parte dello standard IEEE 754, non è un bug di JS. Per controllarlo usa Number.isNaN(x). Il vecchio isNaN globale prima converte l'argomento, e questo dà risposte sbagliate (isNaN("hello") restituisce true). Preferisci sempre la versione Number.isNaN.

Convertire stringhe in numeri in JavaScript

L'input dell'utente e i numeri JSON arrivano spesso come stringhe. Ci sono tre modi per convertirli:

console.log(Number("42"));         // 42
console.log(Number("42px"));       // NaN   (strict)
console.log(parseInt("42px"));     // 42    (permissive, reads digits)
console.log(parseFloat("3.14em")); // 3.14
console.log(+"42");                // 42    (unary plus, same as Number)

console.log(Number(""));           // 0     (!)
console.log(Number(" "));          // 0     (!)

Number() è rigido: qualsiasi cosa non numerica dà NaN, tranne la stringa vuota e gli spazi, che danno 0. parseInt e parseFloat sono tolleranti: leggono finché possono e poi si fermano. Scegli quello che corrisponde alla tua intenzione e controlla se il risultato è NaN prima di usarlo.

Per leggere BigInt da stringhe, usa BigInt("123"): è rigido e lancia un'eccezione se l'input non è valido.

Regole rapide

• Per contatori, calcoli, coordinate e la maggior parte dei numeri di tutti i giorni: usa Number.
• Per il denaro: converti in centesimi interi e usa Number, oppure ricorri a una libreria decimale.
• Per interi più grandi di 2^53 (ID di database, crittografia, calcolo combinatorio): usa BigInt con il suffisso n.
• Confronta i numeri in virgola mobile con una tolleranza, non con ===.
• Rileva i risultati non validi con Number.isNaN e Number.isFinite, non con le versioni globali.
• Non mescolare Number e BigInt nella stessa espressione: converti in modo esplicito.

Prossimo passo: null vs undefined

JavaScript ha due modi per dire "nessun valore", null e undefined, e non sono intercambiabili. Nella prossima pagina vediamo cosa significa ciascuno, in cosa differiscono e quando usare l'uno o l'altro.