Números en

Acerca de Números

En JavaScript hay dos tipos diferentes de números: los números y los «bigints».

Los números son los más utilizados y representan el tipo de dato numérico en el formato de coma flotante de doble precisión de 64 bits.

• number: un tipo de dato numérico en el formato de coma flotante de doble precisión de 64 bits (IEEE 754). Algunos ejemplos son -6, -2.4, 0, 0.1, 1, 3.14, 16.984025, 25, 976, 1024.0 y 500000.
• bigint: un tipo de dato numérico que puede representar enteros en el formato de precisión arbitraria. Algunos ejemplos son -12n, 0n, 4n y 9007199254740991n.

let numericValue = 42;
// => 42

Un literal numérico como 42 en el código JavaScript es un valor de coma flotante, no un entero. No existe un tipo entero independiente de uso común y cotidiano. El tipo bigint no está diseñado para reemplazar al tipo number en los usos cotidianos. 42 sigue siendo un Number, no un BigInt.

Los números también pueden expresarse en formas literales como 0b101, 0o13, 0x0A. Puedes obtener más información sobre la gramática léxica de los números aquí.

Notaciones especiales

Notación exponencial

La notación E indica un número que debe multiplicarse por 10 elevado a una potencia determinada. El formato de la notación E consiste en un número, seguido de e o E y, a continuación, la potencia de 10 por la que hay que multiplicar.

const num = 3.125e7;
// => 31250000
// The notation essentially says, "Take 3.125 and multiply it by 10^7".

La notación E también puede usarse para representar números muy pequeños:

const num = 325987e-6; // Equals 0.325987
// The notation essentially says, "Take 325987 and multiply it by 10^-6.

Notación con guiones bajos

Los guiones bajos pueden usarse para que los números grandes sean más fáciles de leer para el usuario. El compilador ignorará por completo los guiones bajos.

const num = 1_000_000; // You can read this as 1,000,000
console.log(num);
// => 1000000

Objeto integrado

Hay dos objetos integrados que resultan útiles cuando trabajamos con números:

• Number: propiedades estáticas para valores comunes y útiles, métodos estáticos para la comprobación de tipos y la conversión de tipos, métodos de instancia para la conversión de tipos y el formateo de números como strings.
• Math: propiedades y métodos para constantes y funciones matemáticas; no funciona con BigInt.

Math también incluye métodos para redondear números. Puedes leer más sobre las opciones de redondeo disponibles en este artículo de javascript.info sobre el redondeo.

Math.floor(234.34); // => 234
Math.ceil(234.34); // => 235

El Number integrado global object es también una function global que puede usarse para convertir casi cualquier cosa similar a un número en un number. Es menos tolerante que interpretar un string para obtener un number.

const date = new Date('December 17, 1995 03:24:00');
const unix = Number(date);

unix;
// => 819199440000

Hay tres tipos de valores máximos (y mínimos o máximos negativos) para los números en JavaScript:

• VALUE: dados por Number.MAX_VALUE y Number.MIN_VALUE
• INFINITY: dados por Number.POSITIVE_INFINITY y Number.NEGATIVE_INFINITY
• SAFE_INTEGER: dados por Number.MAX_SAFE_INTEGER y Number.MIN_SAFE_INTEGER

Debido a cómo se implementan los números en JavaScript, no todos los números entre Number.MIN_VALUE y Number.MAX_VALUE pueden representarse. Sin embargo, todos los números entre Number.MIN_SAFE_INTEGER - 1 y Number.MAX_SAFE_INTEGER + 1 sí pueden representarse.

Valores numéricos especiales

JavaScript tiene varios valores numéricos especiales:

• Dos valores de error, NaN e Infinity.
• Dos valores para el cero, +0 y -0.

NaN: no es un número

El valor de error NaN (también conocido como «no es un número») se produce en los siguientes casos.

• No se ha podido interpretar un número:

  Number('123'); // => 123
  Number('Hello, World!'); // => NaN
  

• Una operación ha fallado:

  Math.sqrt(-64); // => NaN
  

• Uno de los operandos es NaN:

  NaN + 69; // => NaN
  

NaN es el único valor que no es igual a sí mismo:

NaN === NaN; // => false

Si quieres comprobar si un valor es NaN, tienes que usar la función global isNaN():

isNaN(NaN); // => true
isNaN(123); // => false

Infinity

Infinity es un valor de error que indica uno de estos dos problemas:

• Un número no puede representarse porque su magnitud es demasiado grande.

  Math.pow(2, 1024); // => Infinity
  

• Se ha producido una división por cero.

  6 / 0; // => Infinity
  -6 / 0; // => -Infinity
  

Infinity es mayor que cualquier otro número (excepto NaN). De forma similar, -Infinity es menor que cualquier otro número (excepto NaN).

La función global isFinite() te permite comprobar si un valor es un número real (ni infinito ni NaN):

isFinite(80085); // => true
isFinite(Infinity); // => false
isFinite(NaN); // => false

Los dos ceros

+0 y -0 son números distintos en JavaScript. Pueden producirse si representas un número tan pequeño que resulta indistinguible de 0. El cero con signo te permite registrar «desde qué dirección» te acercaste al cero, es decir, qué signo tenía el número antes de considerarse cero. Lo mejor es actuar como si solo hubiera un cero.

Comparación

Se considera que dos números son iguales si tienen el mismo valor.

1 == 1.0;
// => true

1 === 1.0;
// => true
// Remember, all numbers are floating-points, so this is
// different syntax for the exact same value.

1 === 1n;
// => false
// Strictly checking a number against a bigint will always result
// in false.

Consulta comparación para obtener más información sobre las comparaciones en general y la comparación de valores numéricos en JavaScript.

Errores comunes

Como los números en JavaScript son números de coma flotante, todas las operaciones matemáticas con estos valores son aritmética de coma flotante. Por lo tanto, en JavaScript:

0.1 + 0.2 === 0.3;
// => false

Consulta 0.30000000000000004.com para obtener una explicación breve y el Apéndice D de la guía de cálculo numérico de Oracle «What Every Computer Scientist Should Know About Floating-Point Arithmetic» para obtener una explicación detallada.