El tipo Number en JavaScript

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 edad se ha declarado como un número entero
• La constante pi como un número decimal

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.0025

Operaciones 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 = 0

También podemos utilizar paréntesis para agrupar las operaciones y establecer el orden de precedencia. Por ejemplo:

let resultado = (5 + 10) * 2; // resultado = 30

JavaScript 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 5

Comparaciones 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); // true

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);             // Infinity

De 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);            // -Infinity

NaN 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; // NaN

• Infinity: 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; // -Infinity

Conversió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.

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.30000000000000004

Este 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.3

Debido 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); // true

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).