Operadores aritméticos

Los operadores aritméticos son los símbolos con los que se calcula: +, -, *, /, % y **. Parecen la parte trivial de la programación, y sin embargo dos de ellos —el resto y la división— concentran una cantidad enorme de errores en los primeros programas.

Los seis operadores

10 + 3;   // 13   suma
10 - 3;   // 7    resta
10 * 3;   // 30   multiplicación
10 / 3;   // 3.3333333333333335   división (siempre decimal)
10 % 3;   // 1    resto de la división entera
10 ** 3;  // 1000 potencia

Dos detalles que sorprenden al venir de otros lenguajes:

• La división nunca es entera. 10 / 4 da 2.5, no 2. Si quieres la parte entera usa Math.floor(10 / 4).
• % no es un porcentaje. Es el resto. 10 % 3 es 1 porque 3 cabe tres veces en 10 y sobra 1.

El módulo, que parece inútil hasta que lo necesitas

// ¿Es par?
const esPar = numero % 2 === 0;

// Convertir 145 minutos en horas y minutos
const horas = Math.floor(145 / 60);   // 2
const minutos = 145 % 60;             // 25

// Repartir 17 alumnos en grupos de 5
const gruposCompletos = Math.floor(17 / 5); // 3
const sobran = 17 % 5;                      // 2

En cuanto empiezas a trabajar con bucles y listas, el resto aparece constantemente: alternar filas, agrupar elementos, detectar múltiplos.

Precedencia: quién se calcula antes

Las reglas son las de siempre, con el añadido de que el paréntesis manda:

1. Paréntesis.
2. Potencia (**).
3. Multiplicación, división y resto (*, /, %).
4. Suma y resta (+, -).

2 + 3 * 4;      // 14, no 20
(2 + 3) * 4;    // 20

Consejo práctico: cuando una fórmula tiene más de dos operadores, pon paréntesis aunque no sean necesarios. El código lo lee un humano —tú, dentro de dos semanas— y la ambigüedad cuesta más que los caracteres.

Un cálculo real, paso a paso

Precio con descuento y luego IVA, que es un caso donde el orden cambia el resultado:

const precio = 250;
const descuento = 0.15;
const iva = 0.21;

const conDescuento = precio * (1 - descuento);   // 212.5
const total = conDescuento * (1 + iva);          // 257.125

const totalRedondeado = Math.round(total * 100) / 100; // 257.13

Fíjate en dos decisiones: cada paso queda en su variable con nombre —así se puede depurar— y el redondeo se aplica al final, no en cada paso, para no acumular desviaciones.

Atajos que verás en todas partes

let total = 0;

total += 10;   // total = total + 10
total -= 3;    // total = total - 3
total *= 2;    // total = total * 2

let i = 0;
i++;           // incrementa en 1

+= y ++ son el motor de los contadores: la variable que va sumando dentro de un bucle y guarda el total.

Errores típicos

• Sumar textos sin darte cuenta. "5" + 5 da "55". Revisa los tipos de datos antes de operar.
• Redondear con toFixed y seguir calculando. Devuelve texto: (2.5).toFixed(2) + 1 da "2.501".
• Dividir por cero. No lanza error: da Infinity. Si divides por la longitud de una lista, comprueba primero que no esté vacía.
• Confiar en los decimales. 0.1 + 0.2 !== 0.3. Con dinero, trabaja en céntimos.

Cómo se practica esto en el curso

El módulo 2 dedica varios ejercicios autocorregibles a esto: suma de variables, propina y total, promedio ponderado y cálculo de la hipotenusa con la librería Math. Los tests comprueban el valor exacto, incluido el redondeo, así que un decimal de más se detecta al instante. Es parte del tramo gratuito del curso.