Numeri (Number) di JavaScript

JavaScript ha solo un tipo di numero, senza specifiche separate per interi e numeri a virgola mobile.

Di conseguenza, i numeri possono essere scritti in JavaScript con o senza punto decimale.

var a = 25; // senza punto decimale
var b = 80.05; // con punto decimale

In entrambi i casi, il tipo di dati è un numero e non cambia indipendentemente dal fatto che il numero abbia un punto decimale o no.

È possibile utilizzare la notazione esponenziale scientifica in JavaScript per abbreviare numeri molto grandi o molto piccoli, come mostrato negli esempi seguenti:

let num1 = 957e8; // 95700000000
let num2 = 957e-8; // 0.00000957

I numeri JavaScript sono considerati accurati, con una precisione massima di 15 cifre. Questo significa che i numeri saranno arrotondati dopo aver raggiunto la 16esima cifra:

let num1 = 999999999999999; // Il valore rimane invariato 999999999999999
let num2 = 9999999999999999; // Arrotonda su 10000000000000000

Rappresentazione interna dei numeri

Diversamente da altri linguaggi, JavaScript non definisce diversi tipi di numeri, come interi, short integer, long integer, floating point, ecc.

I numeri JavaScript hanno una precisione di 64 bit, anche noti come double precisione.

La rappresentazione interna si basa sullo standard IEEE 754.

Le 64 bit sono distribuite tra il segno, l'esponente e il numero decimale, come indicato di seguito:

Somma di numeri e concatenazione di stringhe

Come accennato nei capitoli precedenti, l'operatore + viene utilizzato per sommare numeri e concatenare stringhe.

Se sono numeri si sommano. Se sono stringhe si concateneranno.

Se si sommano due numeri, il risultato sarà un numero:

let x = 50;
let y = 10;
let z = x + y; // z = 60 (un numero)

Se sono due stringhe, il risultato sarà una concatenazione di stringhe:

let x = "50";
let y = "10";
let z = x + y; // z = 5010 (una stringa)

Se un numero e una stringa, il risultato sarà una concatenazione di stringhe:

let x = 50;
let y = "10";
let z = x + y; // z = 5010 (una stringa)

Se una stringa e un numero, il risultato sarà una concatenazione di stringhe:

let x = "50";
let y = 10;
let z = x + y; // z = 5010 (una stringa)

JavaScript calcola le espressioni da sinistra a destra. Diversi ordini possono produrre risultati diversi.

Nell'esempio seguente, prima si aggiungono 50 + 10, poiché x e y sono numeri, quindi si concatena 60 + "30", poiché z è una stringa:

let x = 50;
let y = 10;
let z = "30";
let sum = x + y + z; // sum = 6030 (una stringa)

Un errore comune, si aspettava questo risultato di essere 60:

let x = 50;
let y = 10;
let z = "The sum is: " + x + y;

Puoi utilizzare parentesi per risolvere il problema sopra:

let x = 50;
let y = 10;
let z = "The sum is: " + (x + y);

Stringhe numeriche ed espressioni matematiche

Le stringhe JavaScript possono contenere valori numerici.

　　let x = 50; // x è un numero
　　let y = "50"; // y è una stringa

Se la stringa contiene valori numerici, è possibile eseguire espressioni matematiche in JavaScript.

Divisione possibile:

let x = "50" / "10"; // x = 5

Moltiplicazione possibile:

let x = "50" * "10"; // x = 500

Operazione esponenziale possibile:

let x = "5" ** "3"; // x = 125

Incremento possibile:

let x = "50";
x++; // x = 51

Sottrazione possibile:

let x = "50" - "10"; // x = 40

Aggiunta non possibile:

let x = "50" + "10"; // x = 5010

Attenzione:Se si aggiungono due stringhe, il risultato sarà la concatenazione delle stringhe.

NaN-Numero non valido in JavaScript

In JavaScript, i riservati NaN rappresentano numeri non validi.

Se provi a eseguire operazioni matematiche su valori numerici e non numerici, verrà restituito NaN.

var x = 50 / "oldtoolbag.com"; // x = NaN (Not a Number)

Ma se la stringa contiene un valore numerico, puoi eseguire espressioni matematiche con JavaScript:

var x = 50 / "10"; // x = 5

Puoi utilizzare JavaScript globale isNaN()Funzione per determinare se un valore è un numero:

var x = 50 / "oldtoolbag.com";
isNaN(x); // restituisce true perché x non è un numero

Quando si assegna un valore a una variabile utilizzata nell'operazione NaN, anche se l'altro operando è un numero legittimo, si ottiene il seguente valore:

var x = NaN;
var y = 27;
var z = x + y; // z = NaN

NaN è un numero; typeof NaN restituisce number:

typeof NaN; // restituirà "number"

Infinity in JavaScript

Infinity (infinito positivo) o -Infinity (infinito negativo) se il numero calcolato supera il numero massimo disponibile in JavaScript, viene restituito.

Anche per valori non definiti, si verificano queste situazioni, ad esempio quando si divide per zero:

var x = 5 / 0; // restituirà infinito
var y = -5 / 0; // restituirà infinito negativo

In termini tecnici, Infinity (infinito positivo) viene visualizzato come 1.797693134862315E+308 quando il numero supera il numero, rappresentando il limite superiore in JavaScript.

Anche -Infinity (infinito negativo) viene visualizzato come -1.797693134862316E+308 quando il numero supera il limite inferiore.

Infinity è un numero: typeof Infinity restituisce number:

typeof Infinity; // restituirà "number"

Il numero Infinity può essere utilizzato anche nel ciclo:

var num = 5;
while (num != Infinity) {　
// Il codice qui eseguirà fino a num = ∞
}

Base numerica JavaScript

Per impostazione predefinita, JavaScript visualizza i numeri come decimali:10perBaseDecimale.

I numeri possono essere rappresentati anche in esadecimale (base 16), binario (base 2) e ottale (base 8).

Il prefisso di un numero esadecimale è 0x:

var x = 0xFF; // x = 255

Il prefisso di un numero binario è 0b:

var x = 0b1111; // x = 15

Non scrivere un numero che inizia con lo zero (ad esempio 0121). Se il numero è scritto con zero iniziale, JavaScript lo interpreterà come ottale:

var x = 016;

Puoi usare iltoString()Il metodo restituisce un numero da 2 a 36.

, esadecimale èBase 16, decimale èBase 10, ottale èBase 8, binario èBase 2.

var num = 255;
num.toString(10); // restituisce 255
num.toString(16); // restituisce ff
num.toString(8); // restituisce 377
num.toString(2); // restituisce 11111111

Primitivo numerico e oggetto numerico

Di solito, i numeri JavaScript sono valori originali creati da testi:

var num = 50;

Ma può anche essere definito un numero come oggetto utilizzando la parola chiave new:

var num = new Number(50);

Per testare la differenza tra i due, inizializzeremo un primitivo numerico e un oggetto numerico.

var num1 = 50;
var num2 = new Number(50);
typeof num1 // restituisce number
typeof num2 // restituisce object

Attenzione:Non creare numeri come oggetti. Questo ridurrà la velocità di esecuzione e produrrà alcuni risultati imprevisti.

Quando si utilizza l'operatore ==, i numeri sono uguali:

var num1 = 50;
var num2 = new Number(50);
document.write(num1 == num2); // Restituisce true perché num1 e num2 hanno valori uguali

Quando si utilizza l'operatore ===, numeri uguali non sono uguali perché l'operatore === si aspetta valore e tipo uguali:

var num1 = 50;
var num2 = new Number(50);
document.write(num1 === num2); // Restituisce false perché num1 e num2 hanno tipi diversi

Oggetto non confrontabile:

var num1 = new Number(50);
var num2 = new Number(50);
document.write(num1 == num2); // Restituisce false perché num1 e num2 sono oggetti diversi
document.write(num1 === num2); // Restituisce false perché num1 e num2 sono oggetti diversi

Attenzione alla differenza tra (==) e (===). La comparazione di due oggetti JavaScript sempre restituisce false.