Numeri JavaScript
JavaScript ha un solo tipo di numero. I numeri possono essere scritti con o senza decimali.
Esempio
let x = 3.14; // A number with decimals
let y = 3; // A number without decimals
Numeri extra grandi o extra piccoli possono essere scritti con notazione scientifica (esponente):
Esempio
let x = 123e5; // 12300000
let y = 123e-5; // 0.00123
I numeri JavaScript sono sempre in virgola mobile a 64 bit
A differenza di molti altri linguaggi di programmazione, JavaScript non definisce diversi tipi di numeri, come interi, short, long, virgola mobile ecc.
I numeri JavaScript vengono sempre archiviati come numeri in virgola mobile a doppia precisione, secondo lo standard internazionale IEEE 754.
Questo formato memorizza i numeri in 64 bit, dove il numero (la frazione) è memorizzato nei bit da 0 a 51, l'esponente nei bit da 52 a 62 e il segno nel bit 63:
| Valore (aka Frazione/Mantissa) | Esponente | Cartello |
|---|---|---|
| 52 bit (0 - 51) | 11 bit (52 - 62) | 1 bit (63) |
Precisione intera
I numeri interi (numeri senza punto o notazione esponente) sono accurati fino a 15 cifre.
Esempio
let x = 999999999999999; // x will be 999999999999999
let y = 9999999999999999; // y will be 10000000000000000
Il numero massimo di decimali è 17.
Precisione fluttuante
L'aritmetica in virgola mobile non è sempre accurata al 100%:
let x = 0.2 + 0.1;
Per risolvere il problema di cui sopra, è utile moltiplicare e dividere:
let x = (0.2 * 10 + 0.1 * 10) / 10;
Aggiunta di numeri e stringhe
AVVERTIMENTO !!
JavaScript utilizza l'operatore + sia per l'aggiunta che per la concatenazione.
I numeri vengono aggiunti. Le stringhe sono concatenate.
Se aggiungi due numeri, il risultato sarà un numero:
Esempio
let x = 10;
let y = 20;
let z = x + y;
Se aggiungi due stringhe, il risultato sarà una concatenazione di stringhe:
Esempio
let x = "10";
let y = "20";
let z = x + y;
Se aggiungi un numero e una stringa, il risultato sarà una concatenazione di stringhe:
Esempio
let x = 10;
let y = "20";
let z = x + y;
Se aggiungi una stringa e un numero, il risultato sarà una concatenazione di stringhe:
Esempio
let x = "10";
let y = 20;
let z = x + y;
Un errore comune è aspettarsi che questo risultato sia 30:
Esempio
let x = 10;
let y = 20;
let z = "The result is: " + x + y;
Un errore comune è aspettarsi che questo risultato sia 102030:
Esempio
let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;
L'interprete JavaScript funziona da sinistra a destra.
Il primo 10 + 20 viene aggiunto perché xey sono entrambi numeri.
Quindi 30 + "30" viene concatenato perché z è una stringa.
Stringhe numeriche
Le stringhe JavaScript possono avere contenuto numerico:
let x = 100; // x is a number
let y = "100"; // y is a
string
JavaScript proverà a convertire le stringhe in numeri in tutte le operazioni numeriche:
Questo funzionerà:
let x = "100";
let y = "10";
let z = x / y;
Questo funzionerà anche:
let x = "100";
let y = "10";
let z = x * y;
E questo funzionerà:
let x = "100";
let y = "10";
let z = x - y;
Ma questo non funzionerà:
let x = "100";
let y = "10";
let z = x + y;
Nell'ultimo esempio JavaScript usa l'operatore + per concatenare le stringhe.
NaN - Non un numero
NaN è una parola riservata JavaScript che indica che un numero non è un numero legale.
Il tentativo di eseguire aritmetica con una stringa non numerica risulterà in NaN(non un numero):
Esempio
let x = 100 / "Apple";
Tuttavia, se la stringa contiene un valore numerico, il risultato sarà un numero:
Esempio
let x = 100 / "10";
Puoi utilizzare la funzione JavaScript globale isNaN()
per scoprire se un valore non è un numero:
Esempio
let x = 100 / "Apple";
isNaN(x);
Fai attenzione NaN. Se usi NaNin un'operazione matematica, il risultato sarà anche NaN:
Esempio
let x = NaN;
let y = 5;
let z = x + y;
Oppure il risultato potrebbe essere una concatenazione come NaN5:
Esempio
let x = NaN;
let y = "5";
let z = x + y;
NaNè un numero: typeof NaNrestituisce number:
Esempio
typeof NaN;
Infinito
Infinity(o -Infinity) è il valore che JavaScript restituirà se calcoli un numero al di fuori del numero più grande possibile.
Esempio
let myNumber = 2;
// Execute until Infinity
while (myNumber != Infinity) {
myNumber = myNumber * myNumber;
}
La divisione per 0 (zero) genera anche Infinity:
Esempio
let x = 2 / 0;
let y = -2 / 0;
Infinityè un numero: typeof Infinityrestituisce number.
Esempio
typeof Infinity;
Esadecimale
JavaScript interpreta le costanti numeriche come esadecimali se sono precedute da 0x.
Esempio
let x = 0xFF;
Non scrivere mai un numero con uno zero iniziale (come 07).
Alcune versioni di JavaScript interpretano i numeri come ottali se sono scritti con uno zero iniziale.
Per impostazione predefinita, JavaScript visualizza i numeri come base 10 decimali.
Ma puoi usare il toString()metodo per produrre numeri da base 2
a base 36 .
L'esadecimale è in base 16 . Il decimale è in base 10 . Ottale è in base 8 . Il binario è base 2 .
Esempio
let myNumber = 32;
myNumber.toString(10);
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(8);
myNumber.toString(2);
Numeri JavaScript come oggetti
Normalmente i numeri JavaScript sono valori primitivi creati da letterali:
let x = 123;
Ma i numeri possono anche essere definiti come oggetti con la parola chiave new:
let y = new Number(123);
Esempio
let x = 123;
let y = new Number(123);
Non creare oggetti Numero.
La newparola chiave complica il codice e rallenta la velocità di esecuzione.
Gli oggetti numerici possono produrre risultati imprevisti:
Quando si utilizza l' ==operatore, x e y sono uguali :
let x = 500;
let y = new Number(500);
Quando si utilizza l' ===operatore, xey non sono uguali .
let x = 500;
let y = new Number(500);
Nota la differenza tra (x==y)e (x===y).
(x == y) vero o falso?
let x = new Number(500);
let y = new Number(500);
(x === y) vero o falso?
let x = new Number(500);
let y = new Number(500);
Comparing two JavaScript objects always returns false.
Complete JavaScript Number Reference
For a complete Number reference, visit our:
Complete JavaScript Number Reference.
The reference contains descriptions and examples of all Number properties and methods.