Saltar al contenido
Fundamentos del lenguaje

Números

Lección 4 de 913 min4 ejercicios

JavaScript tiene un solo tipo para casi todos los números: number. Sirve para enteros y decimales, positivos y negativos. Es cómodo, pero tiene una consecuencia que sorprende a todo el mundo la primera vez: 0.1 + 0.2 no da 0.3.

Qué mirar en el pizarrón

Cada tarjeta muestra el valor de la variable y, entre paréntesis, cómo se guarda de verdad en binario. Pulsa Siguiente y fíjate de dónde sale el famoso 0.30000000000000004, y cómo lo evita la versión en céntimos.

En el pizarrón

const a = 0.1;const b = 0.2;const suma = a + b;console.log(suma);console.log(suma === 0.3); const centimos = 10 + 20;console.log(centimos / 100);

Variables

  1. a0.1 (en binario: 0.1000000000000000055…)
Consola(vacía)

Los números se guardan en binario. Así como 1/3 no tiene fin en decimal (0.333…), 0.1 no tiene fin en binario. El motor guarda el número más cercano que puede, que es apenas más que 0.1.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: Los números se guardan en binario. Así como 1/3 no tiene fin en decimal (0.333…), 0.1 no tiene fin en binario. El motor guarda el número más cercano que puede, que es apenas más que 0.1. Variables: a 0.1 (en binario: 0.1000000000000000055…).
  2. Paso 2: Con 0.2 pasa lo mismo: también se guarda una aproximación. Variables: a 0.1 (en binario: 0.1000000000000000055…), b 0.2 (en binario: 0.2000000000000000111…).
  3. Paso 3: Al sumar las dos aproximaciones, los pequeños errores se juntan y el resultado se redondea a 0.30000000000000004. Variables: a 0.1 (en binario: 0.1000000000000000055…), b 0.2 (en binario: 0.2000000000000000111…), suma 0.30000000000000004.
  4. Paso 4: console.log muestra el valor tal como quedó. Variables: a 0.1 (en binario: 0.1000000000000000055…), b 0.2 (en binario: 0.2000000000000000111…), suma 0.30000000000000004.
  5. Paso 5: Por eso nunca compares decimales con ===: suma === 0.3 da false. Variables: a 0.1 (en binario: 0.1000000000000000055…), b 0.2 (en binario: 0.2000000000000000111…), suma 0.30000000000000004.
  6. Paso 6: La solución clásica para dinero: trabajar en céntimos, con números enteros. Los enteros se guardan exactos, así que 10 + 20 da 30 sin sorpresas. Variables: a 0.1 (en binario: 0.1000000000000000055…), b 0.2 (en binario: 0.2000000000000000111…), suma 0.30000000000000004, centimos 30.
  7. Paso 7: Solo al final, para mostrarlo, se divide entre 100. Resultado: 0.3. Variables: a 0.1 (en binario: 0.1000000000000000055…), b 0.2 (en binario: 0.2000000000000000111…), suma 0.30000000000000004, centimos 30.

Escribir números

Un número se escribe tal cual, sin comillas. JavaScript acepta varias formas:

console.log(42);          // entero
console.log(-3.75);       // decimal (con punto, nunca con coma)
console.log(1.5e6);       // notación científica: 1.5 × 10⁶ = 1500000
console.log(0xff);        // hexadecimal: 255
console.log(0b1010);      // binario: 10
console.log(1_000_000);   // separadores numéricos: un millón

Los separadores numéricos (_) llegaron en ES2021. El motor los ignora; solo sirven para que las personas lean cifras largas sin contar ceros.

Operadores aritméticos

Operador Qué hace Ejemplo Resultado
+ Suma 7 + 2 9
- Resta 7 - 2 5
* Multiplicación 7 * 2 14
/ División (siempre con decimales) 7 / 2 3.5
% Resto de la división 7 % 2 1
** Potencia 7 ** 2 49

Igual que en matemáticas, *, / y % se calculan antes que + y -, y ** antes que todos. Si dudas, usa paréntesis: (2 + 3) * 4 da 20.

El resto % es más útil de lo que parece: n % 2 === 0 te dice si un número es par.

Por qué 0.1 + 0.2 no da 0.3

Es lo que muestra el pizarrón. Los números se guardan en binario, en un formato estándar llamado IEEE 754, que usan casi todos los lenguajes. Muchos decimales “redondos” no tienen una representación exacta en binario, así que se guarda el valor más cercano posible. Al operar, esos pequeños errores pueden asomar:

console.log(0.1 + 0.2);          // 0.30000000000000004
console.log(1.1 + 2.2);          // 3.3000000000000003
console.log(0.1 + 0.2 === 0.3);  // false

Los enteros, en cambio, se guardan exactos hasta un límite muy grande. Por eso las tres reglas prácticas son:

  • Dinero: trabaja en céntimos (enteros) y divide entre 100 solo para mostrar.
  • Para mostrar decimales, redondea al final: total.toFixed(2) devuelve un texto con dos decimales.
  • Nunca compares decimales con ===. Compara si la diferencia es muy pequeña: Math.abs(a - b) < Number.EPSILON.

Redondear y la caja de herramientas Math

Math reúne las operaciones más comunes:

console.log(Math.round(4.5));   // 5: al entero más cercano
console.log(Math.floor(4.9));   // 4: siempre hacia abajo
console.log(Math.ceil(4.1));    // 5: siempre hacia arriba
console.log(Math.trunc(-4.9));  // -4: quita los decimales
console.log(Math.max(3, 9, 2)); // 9
console.log(Math.min(3, 9, 2)); // 2
console.log(Math.abs(-7));      // 7
console.log(Math.sqrt(81));     // 9

Math.random() devuelve un decimal al azar entre 0 (incluido) y 1 (excluido). Para un entero del 1 al 6, como un dado: Math.floor(Math.random() * 6) + 1.

Sumar muchos decimales: Math.sumPrecise

Cuando sumas muchos números de uno en uno, cada suma intermedia se redondea y los errores se acumulan. Math.sumPrecise (ES2026) recibe la lista completa, calcula la suma exacta y redondea una sola vez, al final:

const valores = [1e20, 0.1, -1e20];

let total = 0;
total = total + valores[0];
total = total + valores[1];
total = total + valores[2];
console.log(total);  // 0: el 0.1 se perdió por el camino

if (typeof Math.sumPrecise === "function") {
  console.log(Math.sumPrecise(valores));  // 0.1
} else {
  console.log("Tu navegador todavía no tiene Math.sumPrecise");
}

Ojo: no hace magia con 0.1 + 0.2. Esos dos valores ya están guardados como aproximaciones, y su suma exacta también se redondea a 0.30000000000000004. Para dinero, la regla de los céntimos sigue siendo la mejor.

Infinity y NaN

Dos valores especiales de tipo number:

  • Infinity: lo que da dividir entre cero, o superar el número más grande posible. Dividir entre cero no lanza un error.
  • NaN (Not a Number): el resultado de una operación numérica sin sentido.
console.log(10 / 0);              // Infinity
console.log(0 / 0);               // NaN
console.log(Number("hola"));      // NaN
console.log(NaN === NaN);         // false: NaN no es igual ni a sí mismo
console.log(Number.isNaN(0 / 0)); // true: así se comprueba

Enteros enormes: BigInt

Un number representa exactos todos los enteros hasta Number.MAX_SAFE_INTEGER, que vale 9007199254740991 (2⁵³ − 1). Por encima empieza a saltarse valores:

console.log(Number.MAX_SAFE_INTEGER);  // 9007199254740991
console.log(9007199254740993);         // 9007199254740992 (¡se comió una unidad!)
console.log(9007199254740993n);        // 9007199254740993n (exacto)
console.log(2n ** 64n);                // 18446744073709551616n

Para esos casos existe BigInt: se escribe con una n al final y no tiene límite de tamaño. Lo vas a necesitar para identificadores enormes, criptografía o cálculos financieros muy grandes. Dos reglas: no puedes mezclarlo con number en una operación (es un TypeError), y no admite decimales.

Resumen

  • number sirve para enteros y decimales. Admite separadores 1_000_000 (ES2021).
  • Operadores: + - * / % **, con la precedencia de las matemáticas.
  • Los decimales son aproximaciones binarias: 0.1 + 0.2 da 0.30000000000000004. Para dinero, usa céntimos.
  • Math tiene redondeos (round, floor, ceil, trunc) y más. Math.sumPrecise (ES2026) suma listas sin acumular errores.
  • Dividir entre cero da Infinity; las operaciones sin sentido dan NaN, que se comprueba con Number.isNaN.
  • Para enteros más allá de 2⁵³ − 1, BigInt, que no se mezcla con number.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Las rarezas de los números

Elige una respuesta en cada pregunta.

  1. ¿Qué da 10 / 0 en JavaScript?

  2. ¿Cómo compruebas si un resultado es NaN?

  3. ¿Qué significa 1_000_000?

  4. Necesitas sumar enteros más grandes que 9007199254740991 sin perder precisión. ¿Qué usas?

Ordena la salida: Operaciones y redondeos

Ordena los resultados tal como aparecerían en la consola. Calcula cada uno antes de mover las tarjetas.

console.log(7 % 3);console.log(2 ** 3);console.log(Math.round(2.5));console.log(Math.floor(-2.5));console.log((0.1 + 0.2).toFixed(2));

Consola, de arriba abajo

  1. -3
  2. 8
  3. 0.30
  4. 1
  5. 3

Detective: El número demasiado grande

Alguien quiso sumarle 1 a un número enorme y obtuvo este error. Encuentra la línea y elige el arreglo que da un resultado exacto.

Consola

contador.js:3
console.log(grande + extra);
                   ^

TypeError: Cannot mix BigInt and other types, use explicit conversions

Paso 1: toca la línea de código que causa el error.

Laboratorio: La cuenta del súper

El pan cuesta 1.10 y la leche 2.20, pero el total sale 3.3000000000000003. Arréglalo sumando en céntimos para que imprima 3.3.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime exactamente 3.3 (pendiente)
  • Pasa los precios a céntimos multiplicando por 100 (pendiente)
  • Redondea los céntimos con Math.round (pendiente)
  • No escribe 3.3 a mano (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.