Operadores en programación: aritméticos, lógicos y de bits

Las herramientas para operar con los datos

En la entrega anterior de la serie de Fundamentos de programación aprendimos a guardar información en variables. Pero una variable parada no sirve de nada. La gracia es operar con ella: sumar dos precios, comprobar si una edad supera los 18, combinar dos condiciones. Para todo eso están los operadores, los símbolos con los que un programa manipula sus datos.

Hay varios grupos y aquí no me dejo ninguno, porque saltarse uno es justo lo que luego te hace mirar un código y no entender qué hace. Vamos por partes.

Operadores aritméticos

Los de toda la vida, para hacer cuentas con números:

• + suma, - resta, * multiplica, / divide.
• % es el módulo: el resto de una división. 7 % 2 da 1, porque 7 entre 2 es 3 y sobra 1. Parece una rareza, pero es utilísimo: numero % 2 == 0 te dice si un número es par. Lo usarás más de lo que crees.
• ** es la potencia en muchos lenguajes. 2 ** 3 da 8 (2 elevado a 3).
• El - también funciona como unario, delante de un solo número, para indicar negativo: -5.
• ++ y -- incrementan o decrementan en uno. contador++ es una forma corta de contador = contador + 1. Aparece por todos lados, sobre todo en bucles.

Un aviso clásico: la división entera. En algunos lenguajes, 7 / 2 da 3 (descarta los decimales) en vez de 3.5, porque ambos números son enteros. Si esperabas el decimal, te llevas un susto. Es uno de esos detalles de tipos que ya avisé que darían guerra.

Operadores de asignación

El = ya lo conoces: mete el valor de la derecha en la variable de la izquierda. Pero hay versiones abreviadas que combinan una operación con la asignación, y se usan constantemente:

saldo = 100
saldo += 50    // equivale a saldo = saldo + 50  -> 150
saldo -= 30    // saldo = saldo - 30  -> 120
saldo *= 2     // saldo = saldo * 2   -> 240
saldo /= 4     // saldo = saldo / 4   -> 60

También existen %= y **=. No aportan nada nuevo, solo se escribe menos. Pero cuando los veas en código ajeno (o de una Inteligencia Artificial), conviene saber que += no es magia: es “súmate esto a ti mismo”.

Operadores de comparación: el lío del =, == y ===

Aquí está el error número uno de todo principiante, y por eso le dedico su propia sección. Atención:

• = (uno) asigna. Mete un valor en una variable.
• == (dos) compara. Pregunta “¿son iguales?” y devuelve verdadero o falso.

edad = 18        // asignación: edad ahora vale 18
edad == 18       // comparación: pregunta si edad es 18 -> verdadero

Confundirlos es la fuente de bugs más típica del mundo. Escribes if (edad = 18) con la intención de comparar, y sin darte cuenta le asignas 18 a la edad dentro del propio if. El programa no falla, pero hace algo distinto de lo esperado, y te vuelves loco buscando el error.

Y por si fuera poco, en lenguajes como JavaScript, TypeScript o PHP hay un tercer nivel: el === (tres). La diferencia:

• == compara valor, y convierte tipos por el camino. Por eso 5 == "5" da verdadero en JavaScript: convierte el texto a número y los ve iguales.
• === compara valor Y tipo, sin convertir nada. 5 === "5" da falso, porque uno es número y el otro texto.

La recomendación de casi todo el mundo es usar siempre === cuando el lenguaje lo tenga, justo para evitar las conversiones automáticas que dan sorpresas. Quédate con esto: = asigna, == compara flojo, === compara estricto.

Lo completan los relacionales de toda la vida: < menor, > mayor, <= menor o igual, >= mayor o igual, y != (distinto, la negación de ==).

Operadores lógicos

Estos combinan condiciones de verdadero/falso, justo la lógica booleana que vimos en la primera entrega:

• && es Y (AND): verdadero solo si las dos partes lo son. edad >= 18 && tieneDNI.
• || es O (OR): verdadero si al menos una lo es. esSabado || esDomingo.
• ! es NO (NOT): invierte. !estaActivo es verdadero cuando NO está activo.

Hay un detalle precioso aquí: el cortocircuito. En un A && B, si A ya es falso, el programa ni se molesta en mirar B (el resultado ya no puede ser verdadero). En un A || B, si A ya es verdadero, tampoco mira B. Esto no solo ahorra trabajo: se usa a propósito para proteger código, como “comprueba que existe el usuario Y, solo entonces, mira su nombre”.

Operadores a nivel de bits

Estos son más avanzados y al principio no los vas a tocar, pero conviene que sepas que existen para no asustarte cuando aparezcan. Operan sobre los unos y ceros internos de los números: & (AND bit a bit), | (OR bit a bit), ^ (XOR), ~ (NOT bit a bit), << y >> (desplazamientos). Se usan en cosas como permisos, gráficos o rendimiento extremo. Por ahora, basta con reconocerlos.

El operador ternario

El ternario es un atajo para una decisión simple en una sola línea. Su forma es condición ? valorSiVerdadero : valorSiFalso:

mensaje = edad >= 18 ? "Adulto" : "Menor"

Eso se lee: “¿edad es mayor o igual que 18? Si sí, mensaje vale ‘Adulto’; si no, ‘Menor’”. Es un condicional comprimido, y lo veremos con calma cuando lleguemos al control de flujo.

Y dos modernos que aparecen mucho hoy en día:

• ?? (coalescencia nula): devuelve lo de la derecha solo si lo de la izquierda es nulo. nombre ?? "Invitado" da “Invitado” si nombre es null.
• ?. (encadenamiento opcional): accede a algo solo si lo anterior existe, sin reventar. usuario?.email no falla aunque usuario sea null.

Precedencia: en qué orden se resuelve todo

Como en matemáticas, los operadores tienen un orden de prioridad. La multiplicación va antes que la suma, los operadores aritméticos antes que los de comparación, y estos antes que los lógicos. 2 + 3 * 4 da 14, no 20, porque el * se resuelve primero.

¿Mi consejo después de treinta años? No te aprendas la tabla de precedencias de memoria. Usa paréntesis. Siempre. Aunque sepas que no hacen falta. Un (edad >= 18) && (tieneDNI || esVIP) se lee de un vistazo y no deja lugar a dudas, ni para ti ni para quien lea tu código después. El código claro gana al código listo.

Lo siguiente: que el programa decida

Ya sabes guardar datos y operar con ellos. Y has visto que muchos operadores devuelven verdadero o falso. ¿Para qué sirve eso? Para que el programa tome decisiones.

En la próxima entrega usamos todo esto en los condicionales: el if / else, donde el programa por fin elige un camino u otro según lo que pase. Aquí es donde la cosa empieza a parecer programación de verdad.

Preguntas frecuentes

¿Cuál es la diferencia entre =, == y ===?

El = asigna: mete un valor en una variable. El == compara si dos valores son iguales y devuelve verdadero o falso, convirtiendo tipos si hace falta (por eso 5 == “5” puede dar verdadero). El ===, en lenguajes como JavaScript o PHP, compara valor y tipo a la vez sin convertir nada (5 === “5” da falso). Se recomienda usar siempre === para evitar conversiones sorpresa.

¿Para qué sirve el operador módulo (%)?

El módulo devuelve el resto de una división: 7 % 2 da 1. Es muy útil en programación: con numero % 2 == 0 sabes si un número es par, y se usa mucho para repartir cosas en grupos, alternar comportamientos o controlar ciclos. Es uno de esos operadores que parecen raros al principio pero acabas usando constantemente.

¿Hace falta memorizar la precedencia de operadores?

No conviene confiar en ella. Aunque cada lenguaje tiene su tabla de prioridades (la multiplicación antes que la suma, lo aritmético antes que lo lógico), lo práctico es usar paréntesis para dejar claro el orden que quieres. El código queda más legible y evitas errores difíciles de detectar, sin depender de recordar una tabla de memoria.

El libro para esta entrega

Los operadores y sus trampas se aprenden tocándolos, así que para esta entrega te recomiendo algo bien práctico: Automatiza las tareas aburridas con Python, de Al Sweigart. Desde el primer capítulo estás operando con datos y montando programillas que sirven para algo. Perfecto para fijar todo esto con las manos.

Este artículo contiene enlaces de afiliado.

Compártelo si te ha resultado útil.

¿Cuántas veces has confundido el = con el == sin darte cuenta? A mí me sigue pasando. Cuéntame tu última pelea con un operador.

Y… en la próxima entrega, el programa empieza a decidir.