Number, BigInt y Math

Para recordar

Number representa enteros y decimales con punto flotante de 64 bits; no todos los decimales ni todos los enteros se representan exactamente. BigInt solo representa enteros. Math reúne funciones estáticas y no se instancia. Los métodos de formato devuelven strings.

Modelo mental de Number

JavaScript usa números de punto flotante IEEE-754 para enteros y decimales. Esto ofrece un rango amplio, pero algunos decimales no se representan de forma exacta y los enteros dejan de ser seguros fuera de Number.MIN_SAFE_INTEGER y Number.MAX_SAFE_INTEGER.

0.1 + 0.2 // 0.30000000000000004
Number.MAX_SAFE_INTEGER // 9007199254740991
Number.isSafeInteger(9007199254740991) // true
Number.isSafeInteger(9007199254740992) // false

Para dinero, trabaja en unidades mínimas enteras —centavos— o usa una librería decimal cuando el dominio exija precisión contable.

Constantes útiles

Constante	Significado
Number.MAX_VALUE	mayor número finito representable
Number.MIN_VALUE	menor número positivo mayor que cero
Number.MAX_SAFE_INTEGER	mayor entero exacto seguro
Number.MIN_SAFE_INTEGER	menor entero exacto seguro
Number.POSITIVE_INFINITY	infinito positivo
Number.NEGATIVE_INFINITY	infinito negativo
Number.NaN	valor numérico inválido
Number.EPSILON	distancia entre 1 y el siguiente Number representable

Number.MAX_SAFE_INTEGER // 9007199254740991
Number.EPSILON // aproximadamente 2.220446049250313e-16

function nearlyEqual(a, b, tolerance = Number.EPSILON) {
  return Math.abs(a - b) <= tolerance * Math.max(1, Math.abs(a), Math.abs(b))
}

nearlyEqual(0.1 + 0.2, 0.3) // true

La tolerancia debe ajustarse a la escala y al dominio; Number.EPSILON no es un margen universal para cualquier cálculo.

Separadores numéricos con _

El guion bajo puede separar grupos dentro de un literal numérico para hacer visible su magnitud. No cambia el valor y JavaScript lo ignora al evaluar.

const oneMillion = 1_000_000
const creditLimit = 25_000_000
const millisecondsPerDay = 86_400_000

oneMillion // 1000000
creditLimit // 25000000
millisecondsPerDay // 86400000

1_000_000 === 1000000 // true

También funciona en decimales, exponentes, otras bases y BigInt:

const precise = 1_234.567_89
const scientific = 1.5e1_0
const permissions = 0b1111_0000
const color = 0xff_88_00
const mask = 0o755
const largeId = 9_007_199_254_740_993n

precise // 1234.56789
scientific // 15000000000
permissions // 240
color // 16746496
mask // 493
largeId // 9007199254740993n

Reglas importantes:

• debe aparecer entre dígitos; no al inicio ni al final;
• no puede quedar junto al punto decimal, e, signo del exponente ni prefijo de base;
• evita agrupaciones ambiguas como 1_00_00; sigue grupos conocidos del dominio;
• funciona en código, no en JSON ni en texto recibido de un formulario.

Number("1_000") // NaN
Number.parseInt("1_000", 10) // 1: se detiene en el guion bajo
JSON.parse('{"total": 1_000}') // SyntaxError

Para mostrar separadores al usuario usa Intl.NumberFormat o toLocaleString; el guion bajo solo mejora la lectura del código fuente.

;(1_000_000).toLocaleString("es-CO")
// '1.000.000'

Convertir y validar

Función o método	Devuelve	Muta	Caso de uso
Number(value)	número o NaN	no	convertir el valor completo
Number.parseInt(text, radix)	entero o NaN	no	leer una parte entera
Number.parseFloat(text)	decimal o NaN	no	leer una parte decimal
Number.isNaN(value)	booleano	no	detectar exactamente NaN
Number.isFinite(value)	booleano	no	aceptar solo números finitos
Number.isInteger(value)	booleano	no	validar enteros
Number.isSafeInteger(value)	booleano	no	validar enteros representables sin pérdida

Number("42") // 42
Number("42px") // NaN
Number("") // 0
Number.parseInt("42px", 10) // 42
Number.parseFloat("3.14rem") // 3.14

Number.isNaN(NaN) // true
Number.isNaN("no") // false
Number.isFinite(20) // true
Number.isFinite("20") // false
Number.isInteger(4.0) // true
Number.isInteger(4.2) // false

Evita la función global isNaN() cuando no quieres coerción: isNaN('texto') es true, mientras Number.isNaN('texto') es false.

Formatear y representar

Método	Devuelve	Muta	Caso de uso
toFixed(digits)	string con decimales fijos	no	visualización simple
toPrecision(digits)	string con cifras significativas	no	mediciones y notación científica
toString(radix?)	string; admite bases 2–36	no	binario, hexadecimal o ids cortos
toLocaleString(locale, options)	string localizado	no	moneda, porcentajes y unidades

const value = 1234.567

value.toFixed(2) // '1234.57'
value
  .toPrecision(4) // '1235'
  (255)
  .toString(16) // 'ff'
  (10)
  .toString(2) // '1010'

  (1234.5)
  .toLocaleString("es-CO", {
    style: "currency",
    currency: "COP"
  })
// resultado localizado, por ejemplo: '$ 1.234,50'

toFixed devuelve texto y redondea para presentar; no corrige la precisión interna ni debe reutilizarse silenciosamente como número de negocio.

Métodos de Math

Math es un objeto estático: no se instancia con new. Sus métodos no mutan los argumentos.

Método	Devuelve	Caso de uso
Math.abs(x)	valor absoluto	distancia o diferencia sin signo
Math.sign(x)	-1, 0, -0, 1 o NaN	conocer dirección
Math.min(...values)	menor valor	límites y estadísticas
Math.max(...values)	mayor valor	límites y estadísticas
Math.sumPrecise(iterable)	suma con menor pérdida de precisión	acumulaciones numéricas sensibles al orden
Math.floor(x)	entero hacia abajo	páginas completas o índice aleatorio
Math.ceil(x)	entero hacia arriba	cantidad de páginas
Math.round(x)	entero más cercano	redondeo general
Math.trunc(x)	parte entera hacia cero	eliminar decimales
Math.pow(base, exponent)	potencia	fórmulas; también base ** exponent
Math.sqrt(x)	raíz cuadrada	geometría
Math.cbrt(x)	raíz cúbica	cálculos volumétricos
Math.hypot(...values)	raíz de suma de cuadrados	distancia euclidiana
Math.random()	número entre 0 incluido y 1 excluido	simulaciones no criptográficas

Math.abs(-8) // 8
Math.sign(-8) // -1
Math.min(4, 1, 9) // 1
Math.max(4, 1, 9) // 9
Math.sumPrecise([1e20, 1, -1e20]) // 1
Math.floor(4.9) // 4
Math.ceil(4.1) // 5
Math.round(4.5) // 5
Math.trunc(-4.9) // -4
Math.pow(2, 3) // 8
2 ** 3 // 8
Math.sqrt(81) // 9
Math.cbrt(27) // 3
Math.hypot(3, 4) // 5

Trigonometría y logaritmos

Math.sin, Math.cos y Math.tan reciben radianes. Math.asin, Math.acos y Math.atan hacen la operación inversa; Math.atan2(y, x) conserva el cuadrante. Math.log, Math.log2 y Math.log10 cubren logaritmos comunes.

const degrees = 180
const radians = degrees * (Math.PI / 180)

Math.sin(radians) // aproximadamente 0
Math.cos(0) // 1
Math.log2(8) // 3
Math.log10(1000) // 3

Referencia de métodos restantes

Familia	Métodos	Qué resuelven
redondeo binario	fround, f16round	aproximar a float de 32 o 16 bits
enteros de 32 bits	imul, clz32	multiplicación y ceros iniciales bitwise
exponenciales	exp, expm1	eˣ y eˣ - 1 con mejor precisión cerca de cero
logaritmos	log, log1p, log2, log10	log natural y variantes
trigonometría	sin, cos, tan, asin, acos, atan, atan2	ángulos en radianes
hiperbólicas	sinh, cosh, tanh, asinh, acosh, atanh	funciones hiperbólicas

Math.fround(1.337) // aproximación Float32: 1.3370000123977661
Math.imul(2, 4) // 8
Math.clz32(1) // 31
Math.exp(1) // 2.718281828459045
Math.expm1(0) // 0
Math.log1p(0) // 0
Math.atan2(1, 1) // aproximadamente 0.785: 45 grados
Math.sinh(0) // 0
Math.asinh(0) // 0

Math.f16round pertenece a ECMAScript 2025 y puede no existir en runtimes antiguos. Está relacionado con Float16Array, explicado en datos binarios.

Sumar con Math.sumPrecise

Una reducción normal suma de izquierda a derecha y redondea después de cada operación. Cuando las magnitudes son muy distintas, ese orden puede borrar componentes pequeños. Math.sumPrecise, incorporado en ECMAScript 2026, recibe un iterable de valores Number y calcula una suma final con menor error acumulado.

const values = [1e20, 1, -1e20]

values.reduce((total, value) => total + value, 0) // 0
Math.sumPrecise(values) // 1

Math.sumPrecise(new Set([0.1, 0.2, 0.3])) // 0.6

No convierte strings ni acepta BigInt: un elemento que no sea Number provoca TypeError. Tampoco convierte JavaScript en aritmética decimal exacta; para dinero o reglas contables siguen siendo preferibles unidades enteras o una solución decimal. Úsalo en estadísticas, mediciones o agregaciones donde el error por orden de suma sea relevante y comprueba compatibilidad del runtime.

Constantes de Math

Constante	Valor aproximado	Uso
Math.PI	3.14159	círculos y ángulos
Math.E	2.71828	crecimiento exponencial
Math.LN2, Math.LN10	0.693, 2.303	logaritmos naturales
Math.LOG2E, Math.LOG10E	1.443, 0.434	conversión de bases
Math.SQRT2	1.414	raíz de 2
Math.SQRT1_2	0.707	raíz de 1/2

Patrones matemáticos frecuentes

Limitar un valor

function clamp(value, min, max) {
  return Math.min(Math.max(value, min), max)
}

clamp(120, 0, 100) // 100
clamp(-5, 0, 100) // 0
clamp(40, 0, 100) // 40

Entero aleatorio dentro de un rango

function randomInteger(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min
}

randomInteger(1, 6) // uno de: 1, 2, 3, 4, 5 o 6

Math.random() no es seguro para tokens, contraseñas, códigos de recuperación ni decisiones de seguridad. En el navegador usa crypto.getRandomValues() o crypto.randomUUID().

crypto.randomUUID()
// ejemplo: 'c5947b4a-18c1-4c0a-a8bb-80cf9e442f06'

BigInt

BigInt representa enteros de tamaño arbitrario. Se crea con el sufijo n o con BigInt(). No puede mezclarse directamente con Number, no admite decimales y JSON.stringify necesita una estrategia explícita.

const largeId = 9_007_199_254_740_993n

largeId + 2n // 9007199254740995n
largeId * 10n // 90071992547409930n
BigInt("123456789") // 123456789n
// largeId + 2        // TypeError: no mezcla BigInt y Number

Caso de uso: calcular paginación

function getPagination(totalItems, pageSize, currentPage) {
  const totalPages = Math.max(1, Math.ceil(totalItems / pageSize))
  const page = Math.min(Math.max(currentPage, 1), totalPages)

  return {
    page,
    totalPages,
    offset: (page - 1) * pageSize
  }
}

getPagination(53, 10, 9)
// { page: 6, totalPages: 6, offset: 50 }