Operadores aritméticos: cuáles son, orden y ejemplos en código

Los operadores aritméticos son los símbolos que realizan operaciones matemáticas entre valores numéricos: suma, resta, multiplicación, división y algunas más que solo existen en programación.

Los básicos los conoces desde la escuela. Lo que suele fallar son tres cosas concretas: el módulo, la división entera y el orden de precedencia. A eso dedico la mayor parte del artículo.

Los operadores básicos

El módulo: el que más se usa y menos se entiende

El módulo devuelve el resto de una división entera. 7 % 3 da 1 porque 3 cabe dos veces en 7 y sobra 1.

Parece poco útil hasta que ves para qué sirve en la práctica:

Saber si un número es par

if (numero % 2 === 0) {
    console.log("Es par");
}

Si al dividir entre 2 no sobra nada, es par. Es la comprobación más habitual de todas.

Alternar filas de una tabla

for (let i = 0; i < filas.length; i++) {
    filas[i].color = (i % 2 === 0) ? "blanco" : "gris";
}

Repartir en grupos cíclicos

const equipos = ["A", "B", "C"];
const equipo = equipos[indice % equipos.length];

Cuando el índice llega al final, el módulo lo devuelve al principio. Es la forma estándar de recorrer algo en ciclo sin salirse del rango.

Convertir unidades

const minutos = 137;
const horas = Math.floor(minutos / 60);   // 2
const resto = minutos % 60;               // 17
// "2 h 17 min"

División entera frente a división normal

Aquí hay una diferencia entre lenguajes que provoca errores difíciles de detectar.

En JavaScript y PHP, / siempre da decimales: 7 / 2 es 3.5.

En Python 3, / da decimales y // da la división entera: 7 / 2 es 3.5 pero 7 // 2 es 3.

En C, C++, Java y C#, si los dos operandos son enteros, la división también es entera. Y esto sorprende a todo el mundo:

int resultado = 7 / 2;      // vale 3, no 3.5
double mal = 7 / 2;         // vale 3.0, ¡ojo!
double bien = 7.0 / 2;      // vale 3.5

En la segunda línea la división ya se hizo entre enteros antes de convertirse a decimal, así que el .5 se perdió antes de asignarse. Es un error clásico en cálculos de promedios y porcentajes.

El orden de precedencia

Cuando hay varios operadores, se resuelven en este orden:

1. Paréntesis ( )
2. Potencia **
3. Multiplicación, división y módulo * / % — de izquierda a derecha
4. Suma y resta + - — de izquierda a derecha

Es la misma regla que en matemáticas. Ejemplos:

2 + 3 * 4        // 14, no 20
(2 + 3) * 4      // 20
10 - 4 - 3       // 3  (se resuelve de izquierda a derecha)
2 ** 3 ** 2      // 512, la potencia va de derecha a izquierda

Ese último caso sorprende: 2 ** 3 ** 2 se evalúa como 2 ** (3 ** 2) = 2 ** 9 = 512, no como (2 ** 3) ** 2 = 64. Es el único operador aritmético asociativo por la derecha.

Consejo: usa paréntesis aunque no hagan falta. No cambian el rendimiento y eliminan cualquier duda para quien lea el código después, incluido tú dentro de seis meses.

Operadores de incremento y asignación

La diferencia entre x++ y ++x

Los dos suman 1. La diferencia está en qué valor devuelven cuando se usan dentro de otra expresión:

let a = 5;
console.log(a++);   // imprime 5, y después a vale 6
                    // (post-incremento: usa el valor y luego suma)

let b = 5;
console.log(++b);   // imprime 6
                    // (pre-incremento: suma primero y luego usa el valor)

Si usas el incremento en una línea aparte, da igual cuál elijas. Solo importa cuando lo mezclas con otra operación, y precisamente por eso conviene no mezclarlo: el código gana en claridad.

El problema de los decimales

Prueba esto en cualquier lenguaje:

console.log(0.1 + 0.2);    // 0.30000000000000004

No es un fallo del lenguaje. Los números decimales se guardan en binario siguiendo el estándar de coma flotante, y algunos valores como 0,1 no tienen representación exacta en binario, igual que 1/3 no la tiene en decimal.

Consecuencia práctica: nunca compares decimales con igualdad exacta.

// mal
if (total === 0.3) { ... }

// bien
if (Math.abs(total - 0.3) < 0.0001) { ... }

Y sobre todo: para dinero, no uses decimales. Guarda los importes en céntimos como números enteros y divide solo al mostrarlos. Es lo que hacen los sistemas de pago serios, y evita que en una factura aparezca 19,999999 en vez de 20.

Otros errores frecuentes

División entre cero. En la mayoría de lenguajes lanza un error. En JavaScript devuelve Infinity, y 0/0 devuelve NaN. Comprueba siempre el divisor antes.

Sumar texto y número. En JavaScript, "5" + 3 da "53" porque concatena, pero "5" - 3 da 2 porque la resta fuerza la conversión. Convierte explícitamente con Number() o parseInt().

Desbordamiento. En lenguajes con enteros de tamaño fijo, superar el máximo hace que el número "dé la vuelta" y se vuelva negativo. Si trabajas con cifras grandes, usa un tipo adecuado.

Preguntas frecuentes

¿Para qué sirve el módulo aparte de saber si es par?
Para ciclos, conversión de unidades, distribuir elementos en grupos y calcular dígitos de control.

¿Por qué 7/2 me da 3 en Java?
Porque ambos operandos son enteros y la división también lo es. Escribe 7.0/2 para obtener 3.5.

¿Es lo mismo % que porcentaje?
No. En programación % es el resto de la división. Para un porcentaje se multiplica y se divide entre 100.

¿Cómo redondeo un resultado?
Con Math.round() al entero más cercano, Math.floor() hacia abajo y Math.ceil() hacia arriba. Para decimales fijos, toFixed(2), aunque devuelve texto.

---

¿Empezando a programar? En nuestro catálogo de cursos técnicos encuentras formación desde cero, con acceso inmediato y de por vida.