Números JavaScript
JavaScript tiene un solo tipo de número. Los números se pueden escribir con o sin decimales.
Ejemplo
let x = 3.14; // A number with decimals
let y = 3; // A number without decimals
Los números extra grandes o extra pequeños se pueden escribir con notación científica (exponente):
Ejemplo
let x = 123e5; // 12300000
let y = 123e-5; // 0.00123
Los números de JavaScript son siempre de punto flotante de 64 bits
A diferencia de muchos otros lenguajes de programación, JavaScript no define diferentes tipos de números, como enteros, cortos, largos, de coma flotante, etc.
Los números de JavaScript siempre se almacenan como números de punto flotante de doble precisión, siguiendo el estándar internacional IEEE 754.
Este formato almacena números en 64 bits, donde el número (la fracción) se almacena en los bits 0 a 51, el exponente en los bits 52 a 62 y el signo en el bit 63:
Valor (también conocido como Fracción/Mantisa) | Exponente | Firmar |
---|---|---|
52 bits (0 - 51) | 11 bits (52 - 62) | 1 bit (63) |
Precisión de enteros
Los números enteros (números sin notación de punto o exponente) tienen una precisión de hasta 15 dígitos.
Ejemplo
let x = 999999999999999; // x will be 999999999999999
let y = 9999999999999999; // y will be 10000000000000000
El número máximo de decimales es 17.
Precisión flotante
La aritmética de punto flotante no siempre es 100% precisa:
let x = 0.2 + 0.1;
Para resolver el problema anterior, es útil multiplicar y dividir:
let x = (0.2 * 10 + 0.1 * 10) / 10;
Adición de números y cadenas
ADVERTENCIA !!
JavaScript usa el operador + tanto para la suma como para la concatenación.
Se agregan números. Las cadenas se concatenan.
Si sumas dos números, el resultado será un número:
Ejemplo
let x = 10;
let y = 20;
let z = x + y;
Si agrega dos cadenas, el resultado será una concatenación de cadenas:
Ejemplo
let x = "10";
let y = "20";
let z = x + y;
Si agrega un número y una cadena, el resultado será una concatenación de cadenas:
Ejemplo
let x = 10;
let y = "20";
let z = x + y;
Si agrega una cadena y un número, el resultado será una concatenación de cadenas:
Ejemplo
let x = "10";
let y = 20;
let z = x + y;
Un error común es esperar que este resultado sea 30:
Ejemplo
let x = 10;
let y = 20;
let z = "The result is: " + x + y;
Un error común es esperar que este resultado sea 102030:
Ejemplo
let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;
El intérprete de JavaScript funciona de izquierda a derecha.
Primero se suma 10 + 20 porque x e y son números.
Entonces 30 + "30" se concatena porque z es una cadena.
Cadenas numéricas
Las cadenas de JavaScript pueden tener contenido numérico:
let x = 100; // x is a number
let y = "100"; // y is a
string
JavaScript intentará convertir cadenas en números en todas las operaciones numéricas:
Esto funcionará:
let x = "100";
let y = "10";
let z = x / y;
Esto también funcionará:
let x = "100";
let y = "10";
let z = x * y;
Y esto funcionará:
let x = "100";
let y = "10";
let z = x - y;
Pero esto no funcionará:
let x = "100";
let y = "10";
let z = x + y;
En el último ejemplo, JavaScript usa el operador + para concatenar las cadenas.
NaN - No es un número
NaN
es una palabra reservada de JavaScript que indica que un número no es un número legal.
Intentar hacer aritmética con una cadena no numérica dará como resultado NaN
(No es un número):
Ejemplo
let x = 100 / "Apple";
Sin embargo, si la cadena contiene un valor numérico, el resultado será un número:
Ejemplo
let x = 100 / "10";
Puede usar la función global de JavaScript isNaN()
para averiguar si un valor no es un número:
Ejemplo
let x = 100 / "Apple";
isNaN(x);
Cuidado NaN
con Si utiliza NaN
en una operación matemática, el resultado también será NaN
:
Ejemplo
let x = NaN;
let y = 5;
let z = x + y;
O el resultado podría ser una concatenación como NaN5:
Ejemplo
let x = NaN;
let y = "5";
let z = x + y;
NaN
es un número: typeof NaN
devuelve number
:
Ejemplo
typeof NaN;
infinito
Infinity
(o -Infinity
) es el valor que JavaScript devolverá si calcula un número fuera del número más grande posible.
Ejemplo
let myNumber = 2;
// Execute until Infinity
while (myNumber != Infinity) {
myNumber = myNumber * myNumber;
}
La división por 0 (cero) también genera Infinity
:
Ejemplo
let x = 2 / 0;
let y = -2 / 0;
Infinity
es un número: typeof Infinity
devuelve number
.
Ejemplo
typeof Infinity;
hexadecimal
JavaScript interpreta las constantes numéricas como hexadecimales si están precedidas por 0x.
Ejemplo
let x = 0xFF;
Nunca escriba un número con un cero a la izquierda (como 07).
Algunas versiones de JavaScript interpretan los números como octales si se escriben con un cero inicial.
De forma predeterminada, JavaScript muestra los números como decimales en base 10 .
Pero puede usar el toString()
método para generar números desde la base 2
hasta la base 36 .
El hexadecimal es base 16 . El decimal es base 10 . Octal es base 8 . El binario es base 2 .
Ejemplo
let myNumber = 32;
myNumber.toString(10);
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(8);
myNumber.toString(2);
Números de JavaScript como objetos
Normalmente, los números de JavaScript son valores primitivos creados a partir de literales:
let x = 123;
Pero los números también se pueden definir como objetos con la palabra clave new
:
let y = new Number(123);
Ejemplo
let x = 123;
let y = new Number(123);
No cree objetos numéricos.
La new
palabra clave complica el código y ralentiza la velocidad de ejecución.
Los objetos numéricos pueden producir resultados inesperados:
Cuando se usa el ==
operador, x e y son iguales :
let x = 500;
let y = new Number(500);
Cuando se usa el ===
operador, x e y no son iguales .
let x = 500;
let y = new Number(500);
Tenga en cuenta la diferencia entre (x==y)
y (x===y)
.
(x == y)
¿verdadero o falso?
let x = new Number(500);
let y = new Number(500);
(x === y)
¿verdadero 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.