En JavaScript, el tipo de dato Number nos permite manejar valores numéricos y realizar operaciones matemáticas con ellos.
A diferencia de otros lenguajes que tienen diferentes tipos para enteros y números flotantes, JavaScript utiliza un solo tipo para ambos casos. Esto simplifica la manipulación de números (pero también introduce ciertos problemas, que veremos al final).
Declaración de variables tipo Number
Para declarar una variable con un valor numérico, simplemente usamos la palabra clave let o const, seguido por el nombre de la variable y el valor que le queremos asignar. Por ejemplo:
let edad = 25;
const pi = 3.14159;
En este caso,
- La variable
edadse ha declarado como un número entero - La constante
picomo un número decimal
Como habíamos dicho, en JavaScript no hay diferencia entre crear un número con decimales o sin decimales
También es posible emplear notación científica, cuando trabajamos con números muy grandes o muy pequeños.
const grande = 1.5e10; // 15,000,000,000
const pequeño = 2.5e-3; // 0.0025Operaciones aritméticas con tipo Number
Podemos realizar operaciones aritméticas con variables de tipo Number utilizando los operadores matemáticos básicos.
let a = 10;
let b = 5;
let c = a + b; // c = 15
let d = a - b; // d = 5
let e = a * b; // e = 50
let f = a / b; // f = 2
let g = a % b; // g = 0También podemos utilizar paréntesis para agrupar las operaciones y establecer el orden de precedencia. Por ejemplo:
let resultado = (5 + 10) * 2; // resultado = 30JavaScript también tiene operadores de incremento (++) y decremento (--), que son útiles para manipular números de forma rápida:
let x = 5;
x++; // Ahora x es 6
x--; // Ahora x vuelve a ser 5Comparaciones y ordenación
Los números pueden compararse usando los operadores de comparación estándar:
let x = 5;
let y = 10;
console.log(x > y); // false
console.log(x < y); // true
console.log(x === y); // false
console.log(x !== y); // trueHay que tener en cuenta los posibles problemas de precisión. Lo vemos más abajo 👇
Rango de valores permitidos
El tipo Number puede manejar un rango muy grande de valores , aunque no infinito. El valor máximo que puede representarse es Number.MAX_VALUE, que es aproximadamente 1.79e+308.
Si se supera este valor, se obtiene el valor Infinity:
console.log(Number.MAX_VALUE); // 1.7976931348623157e+308
console.log(1e309); // InfinityDe manera similar, el valor más pequeño que puede representarse es Number.MIN_VALUE, que es aproximadamente 5e-324.
console.log(Number.MIN_VALUE); // 5e-324
console.log(-1e309); // -InfinityNaN y Infinity
Además de los valores numéricos habituales, Javascript también tiene dos valores especiales que pertenecen al tipo Number: NaN e Infinity.
NaN: significa “Not a Number”. Es el resultado de una operación aritmética que no tiene sentido, como la división entre cero, o la conversión de una cadena de texto que no puede ser interpretada como un número.
let numero = "texto" * 2; // NaNInfinity: representa un valor numérico infinito, positivo o negativo. Se puede obtener al dividir un número cualquiera entre cero o al exceder los límites del tipo Number.
let inf = 1 / 0; // Infinity
let menosInf = -1 / 0; // -InfinityConversión de tipos de datos
Conversión implícita
JavaScript realiza conversiones implícitas entre tipos cuando se utilizan operadores que requieren tipos específicos. Por ejemplo, la suma de un número y una cadena convierte el número a una cadena:
let number = 5;
let text = " apples";
let result = number + text; // "5 apples"Conversión explícita
Puedes convertir valores explícitamente utilizando las funciones Number(), String(), parseInt(), y parseFloat():
let stringNumber = "42";
let number = Number(stringNumber); // 42
let floatNumber = parseFloat("3.14"); // 3.14
let intNumber = parseInt("101", 2); // 5 (en base 2)Métodos para manipular Number
JavaScript proporciona muchos métodos para trabajar con Numbers.
Lo vemos en la entrada
Problemas de precisión en Number
La representación de punto flotante de doble precisión puede llevar a problemas de precisión debido a la forma en que los números decimales son almacenados en la memoria. Por ejemplo:
console.log(0.1 + 0.2); // 0.30000000000000004Este resultado inesperado se debe a que algunos números decimales no pueden representarse con precisión en binario.
Para resolver estos problemas de precisión, es común utilizar técnicas como el redondeo:
let resultado = 0.1 + 0.2;
console.log(Math.round(resultado * 100) / 100); // 0.3Debido a estos problemas, las comparaciones de números pueden ser problemáticas. Por eso, e en lugar de usar comparaciones directas, es mejor usar una tolerancia o un margen de error:
let x = 0.1 + 0.2;
let y = 0.3;
let epsilon = 1e-10; // Tolerancia
console.log(Math.abs(x - y) < epsilon); // trueEsto no es un problema de JavaScript, si no que es común a muchos lenguajes Más información en Cómo representar números fraccionarios en binario
Representación en bits Avanzado
Los valores numéricos en JavaScript se basan en el estándar IEEE 754, lo que significa que todos los números se representan en formato de 64 bits de doble precisión (Double Precision Floating Point).
El tipo Number utiliza 64 bits en la memoria, de los cuales:
- 1 bit es para el signo (positivo o negativo),
- 11 bits son para el exponente,
- 52 bits son para la mantisa (la parte significativa del número).