Numeri in

Informazioni su Numeri

In JavaScript esistono due tipi diversi di numeri: il tipo number e il tipo bigint.

I numeri sono quelli più usati e rappresentano il tipo di dato numerico nel formato in virgola mobile a doppia precisione a 64 bit.

• number: un tipo di dato numerico nel formato in virgola mobile a doppia precisione a 64 bit (IEEE 754). Gli esempi sono -6, -2.4, 0, 0.1, 1, 3.14, 16.984025, 25, 976, 1024.0 e 500000.
• bigint: un tipo di dato numerico che può rappresentare interi nel formato a precisione arbitraria. Gli esempi sono -12n, 0n, 4n e 9007199254740991n.

let numericValue = 42;
// => 42

Un valore letterale numerico come 42 nel codice JavaScript è un valore in virgola mobile, non un intero. Nell'uso comune quotidiano non esiste un tipo separato per gli interi. Il tipo bigint non è pensato per sostituire il tipo number negli usi quotidiani. 42 è comunque un Number, non un BigInt.

I numeri possono anche essere espressi in forme letterali come 0b101, 0o13, 0x0A. Scopri di più sulla grammatica lessicale numerica qui.

Notazioni speciali

Notazione esponenziale

La notazione E indica un numero che va moltiplicato per 10 elevato a una certa potenza. Il formato della notazione E prevede un numero, seguito da e o E, e poi dalla potenza di 10 per cui moltiplicare.

const num = 3.125e7;
// => 31250000
// The notation essentially says, "Take 3.125 and multiply it by 10^7".

La notazione E può anche essere usata per rappresentare numeri molto piccoli:

const num = 325987e-6; // Equals 0.325987
// The notation essentially says, "Take 325987 and multiply it by 10^-6.

Notazione con underscore

Gli underscore possono essere usati per rendere i numeri grandi più facili da leggere. Il compilatore ignora completamente gli underscore.

const num = 1_000_000; // You can read this as 1,000,000
console.log(num);
// => 1000000

Oggetto integrato

Ci sono due oggetti integrati che tornano utili quando si ha a che fare con i numeri:

• Number: proprietà statiche per valori comuni e utili, metodi statici per il controllo dei tipi e la conversione dei tipi, metodi di istanza per la conversione dei tipi e per formattare i numeri come stringhe.
• Math: proprietà e metodi per costanti e funzioni matematiche, non funziona con BigInt.

Math include anche metodi per arrotondare i numeri. Puoi leggere di più sulle opzioni di arrotondamento disponibili in questo articolo di javascript.info sull'arrotondamento.

Math.floor(234.34); // => 234
Math.ceil(234.34); // => 235

L'object globale integrato Number è anche una function globale che può essere usata per convertire in number quasi qualsiasi cosa di simile a un numero. È meno indulgente del parsing di una string in un number.

const date = new Date('December 17, 1995 03:24:00');
const unix = Number(date);

unix;
// => 819199440000

In JavaScript esistono tre tipi di valori massimi (e minimi / massimi negativi) per i numeri:

• VALUE: dato da Number.MAX_VALUE e Number.MIN_VALUE
• INFINITY: dato da Number.POSITIVE_INFINITY e Number.NEGATIVE_INFINITY
• SAFE_INTEGER: dato da Number.MAX_SAFE_INTEGER e Number.MIN_SAFE_INTEGER

Per come sono implementati i numeri in JavaScript, non tutti i numeri compresi tra Number.MIN_VALUE e Number.MAX_VALUE possono essere rappresentati. Tuttavia, tutti i numeri compresi tra Number.MIN_SAFE_INTEGER - 1 e Number.MAX_SAFE_INTEGER + 1 possono essere rappresentati.

Valori numerici speciali

JavaScript ha diversi valori numerici speciali:

• Due valori di errore, NaN e Infinity.
• Due valori per lo zero, +0 e -0.

NaN: Not a Number

Il valore di errore NaN (noto anche come «Not a Number») viene prodotto nei seguenti casi.

• Non è stato possibile fare il parsing di un numero:

  Number('123'); // => 123
  Number('Hello, World!'); // => NaN
  

• Un'operazione non è riuscita:

  Math.sqrt(-64); // => NaN
  

• Uno degli operandi è NaN:

  NaN + 69; // => NaN
  

NaN è l'unico valore che non è uguale a se stesso:

NaN === NaN; // => false

Se vuoi verificare se un valore è NaN, devi usare la funzione globale isNaN():

isNaN(NaN); // => true
isNaN(123); // => false

Infinity

Infinity è un valore di errore che indica uno di due problemi:

• Un numero non può essere rappresentato perché la sua grandezza è troppo grande.

  Math.pow(2, 1024); // => Infinity
  

• È avvenuta una divisione per zero.

  6 / 0; // => Infinity
  -6 / 0; // => -Infinity
  

Infinity è più grande di qualsiasi altro numero (tranne NaN). Allo stesso modo, -Infinity è più piccolo di qualsiasi altro numero (tranne NaN).

La funzione globale isFinite() ti permette di verificare se un valore è un numero reale (né infinito né NaN):

isFinite(80085); // => true
isFinite(Infinity); // => false
isFinite(NaN); // => false

I due zeri

+0 e -0 sono numeri distinti in JavaScript. Si possono produrre rappresentando un numero così piccolo da essere indistinguibile da 0. Lo zero con segno ti permette di registrare «da quale direzione» ti sei avvicinato allo zero, cioè quale segno aveva il numero prima di essere considerato zero. La buona pratica è fare finta che esista un solo zero.

Confronto

Due numeri sono considerati uguali se hanno lo stesso valore.

1 == 1.0;
// => true

1 === 1.0;
// => true
// Remember, all numbers are floating-points, so this is
// different syntax for the exact same value.

1 === 1n;
// => false
// Strictly checking a number against a bigint will always result
// in false.

Vedi confronto per maggiori informazioni sui confronti in generale e sul confronto di valori numerici in JavaScript.

Insidie

Poiché i numeri in JavaScript sono numeri in virgola mobile, tutta la matematica che usa questi valori è matematica in virgola mobile. Quindi, in JavaScript:

0.1 + 0.2 === 0.3;
// => false

Vedi 0.30000000000000004.com per una breve spiegazione e l'Appendice D della guida Numerical Computation Guide di Oracle, «What Every Computer Scientist Should Know About Floating-Point Arithmetic», per una spiegazione approfondita.