11. Números decimales y precisión numérica

11.1 Introducción

Los decimales aparecen cuando una cantidad no es entera: precios, porcentajes, promedios, distancias, velocidades, probabilidades, coordenadas y mediciones.

En matemática podemos escribir valores como 0.1, 2.75 o 3.1416. En programación, esos valores deben almacenarse en memoria usando una representación finita. Esa limitación puede producir pequeñas diferencias entre el resultado esperado y el resultado real.

En JavaScript, los números comunes usan el tipo number, que representa enteros y decimales con formato de punto flotante.

11.2 Qué es un número decimal

Un número decimal tiene una parte entera y una parte decimal separadas por un punto en JavaScript. En español solemos escribir coma decimal, pero en código JavaScript se usa punto.

const precio = 19.99;
const temperatura = 36.6;
const promedio = 8.75;

console.log(precio);
console.log(temperatura);
console.log(promedio);

11.3 Decimales como fracciones

Muchos decimales pueden interpretarse como fracciones. Por ejemplo, 0.5 equivale a 1/2 y 0.25 equivale a 1/4.

console.log(1 / 2);
console.log(1 / 4);
console.log(3 / 4);
console.log(1 / 10);

11.4 El problema de la representación

Las computadoras representan internamente los números en base 2. Algunos decimales que son simples en base 10 no tienen una representación exacta en base 2.

Por eso puede aparecer un resultado inesperado al sumar decimales aparentemente simples.

console.log(0.1 + 0.2);
console.log(0.3);

El resultado está muy cerca de 0.3, pero no es exactamente igual. Este fenómeno no es exclusivo de JavaScript; ocurre en muchos lenguajes que usan punto flotante binario.

11.5 Comparar decimales con cuidado

Debido a los pequeños errores de representación, comparar decimales con igualdad exacta puede fallar.

const resultado = 0.1 + 0.2;

console.log(resultado === 0.3);

Para comparar decimales, suele ser mejor verificar si la diferencia entre dos valores es suficientemente pequeña.

const resultado = 0.1 + 0.2;
const esperado = 0.3;
const tolerancia = 0.0000001;

console.log(Math.abs(resultado - esperado) < tolerancia);

11.6 Number.EPSILON

JavaScript ofrece Number.EPSILON, un valor muy pequeño que representa una diferencia mínima útil para comparar números cercanos a 1.

const resultado = 0.1 + 0.2;
const esperado = 0.3;

console.log(Math.abs(resultado - esperado) < Number.EPSILON);

Para valores grandes o cálculos acumulados, puede convenir definir una tolerancia propia según el problema.

11.7 Redondear con Math.round()

Redondear significa aproximar un número al entero o cantidad de decimales deseada. Math.round() redondea al entero más cercano.

console.log(Math.round(4.2));
console.log(Math.round(4.5));
console.log(Math.round(4.8));

El redondeo es útil para mostrar resultados, pero hay que distinguir entre el valor interno y la forma en que se presenta al usuario.

11.8 Redondear a cierta cantidad de decimales

Para redondear a dos decimales, una técnica común es multiplicar por 100, redondear y luego dividir por 100.

const valor = 12.3456;
const redondeado = Math.round(valor * 100) / 100;

console.log(redondeado);

Esta técnica puede adaptarse cambiando el factor: 10 para un decimal, 1000 para tres decimales, y así sucesivamente.

11.9 toFixed()

El método toFixed() devuelve una cadena de texto con una cantidad fija de decimales. Es muy útil para mostrar precios o medidas.

const precio = 19.9;
const promedio = 8.756;

console.log(precio.toFixed(2));
console.log(promedio.toFixed(1));
console.log(typeof precio.toFixed(2));

Es importante recordar que toFixed() devuelve texto, no un número.

11.10 Math.floor(), Math.ceil() y Math.trunc()

JavaScript tiene varias formas de aproximar un decimal a un entero.

const valor = 4.8;

console.log(Math.floor(valor));
console.log(Math.ceil(valor));
console.log(Math.trunc(valor));
console.log(Math.round(valor));

11.11 Cálculos con dinero

Los errores de precisión son especialmente sensibles cuando trabajamos con dinero. Una práctica común es guardar montos en centavos como enteros y convertir a pesos o dólares solo para mostrar.

const precioCentavos = 1999;
const cantidad = 3;
const totalCentavos = precioCentavos * cantidad;
const total = totalCentavos / 100;

console.log(totalCentavos);
console.log(total.toFixed(2));

Trabajar con enteros reduce problemas de precisión en sumas y multiplicaciones de importes.

11.12 Acumulación de errores

Un error muy pequeño puede volverse visible cuando se repite muchas veces. Por eso conviene tener cuidado con sumas acumuladas de decimales.

let total = 0;

for (let i = 0; i < 10; i++) {
  total = total + 0.1;
}

console.log(total);

Una alternativa, si el problema lo permite, es trabajar con enteros escalados.

let totalDecimas = 0;

for (let i = 0; i < 10; i++) {
  totalDecimas = totalDecimas + 1;
}

console.log(totalDecimas / 10);

11.13 Formatear números para mostrar

Para mostrar números al usuario, muchas veces conviene formatearlos. Intl.NumberFormat permite adaptar separadores, decimales y estilos según una configuración regional.

const numero = 1234567.89;

const formatoArgentina = new Intl.NumberFormat("es-AR", {
  minimumFractionDigits: 2,
  maximumFractionDigits: 2
});

console.log(formatoArgentina.format(numero));

Esto afecta la presentación, no el valor matemático interno.

11.14 Errores comunes

• Comparar decimales con igualdad exacta después de varios cálculos.
• Olvidar que toFixed() devuelve texto.
• Usar decimales directamente para dinero sin evaluar el riesgo de precisión.
• Confundir redondear para mostrar con redondear para seguir calculando.
• Suponer que todos los decimales se almacenan de forma exacta.

const valor = 10.5;
const texto = valor.toFixed(2);

console.log(texto);
console.log(typeof texto);
console.log(Number(texto) + 1);

11.15 Qué debes recordar de este tema

• En JavaScript los decimales se escriben con punto.
• Muchos decimales no se representan exactamente en memoria.
• La suma 0.1 + 0.2 muestra un error típico de punto flotante.
• Para comparar decimales conviene usar una tolerancia.
• Math.round(), Math.floor(), Math.ceil() y Math.trunc() aproximan valores de diferentes maneras.
• toFixed() sirve para mostrar decimales, pero devuelve texto.
• Para dinero suele convenir trabajar con centavos como enteros.

11.16 Conclusión

Los números decimales son indispensables para representar medidas, precios y promedios, pero deben usarse con atención. La precisión numérica no es un detalle menor: puede afectar comparaciones, acumulaciones, reportes y cálculos financieros.

En el próximo tema estudiaremos razones y proporciones, donde los decimales y las fracciones se aplican para comparar cantidades.