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 usados y representan el tipo de dato numérico en el formato de punto flotante de doble precisión de 64 bits.

• number: un tipo de dato numérico en el formato de punto 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 de JavaScript es un valor de punto flotante, no un entero. En el uso cotidiano no existe un tipo entero separado. 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 se pueden expresar en formas literales como 0b101, 0o13, 0x0A. Aprende más 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 dada. El formato de la notación E consiste en un número seguido de e o E y, después, la potencia de 10 por la que se multiplica.

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

La notación E también se puede usar 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 se pueden usar para que los números grandes sean más fáciles de leer. 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 incorporado

Hay dos objetos incorporados que son útiles cuando trabajas con números:

• Number: propiedades estáticas para valores comunes o útiles, métodos estáticos para la verificación de tipos y la conversión de tipos, y 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 object global incorporado Number es también una function global que se puede usar para convertir casi cualquier cosa que se parezca a un número en un number. Es menos permisivo que parsear un string a 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 se pueden representar. Sin embargo, todos los números entre Number.MIN_SAFE_INTEGER - 1 y Number.MAX_SAFE_INTEGER + 1 sí se pueden representar.

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 pudo parsear un número:

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

• Una operación falló:

  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 dos problemas:

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

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

• Ha ocurrido una división por cero.

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

Infinity es mayor que cualquier otro número (excepto NaN). Del mismo modo, -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. Se pueden producir si representaste un número tan pequeño que es 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 que se considerara cero. La mejor práctica es actuar como si solo hubiera un cero.

Comparación

Dos números se consideran 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.

Trampas

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

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

Consulta 0.30000000000000004.com para ver una explicación breve y el Apéndice D de la Guía de Computación Numérica de Oracle, «What Every Computer Scientist Should Know About Floating-Point Arithmetic», para obtener una explicación detallada.