Operadores básicos

Al trabajar con Javascript (o con cualquier lenguaje de programación), es muy habitual hacer uso de los llamados operadores. Se trata de unos símbolos que nos permitirán hacer una serie de operaciones con uno o más operadores (generalmente, números). Sin embargo, esto se entiende mejor con ejemplos, por lo que vamos a desglosar los operadores básicos en una serie de bloques y a explicarlos para que se entienda lo mejor posible:

• Aritméticos: Operadores para realizar operaciones matemáticas.
• Asignación: Operadores para guardar información en variables.
• Unarios: Operadores que se utilizan con un sólo operando.
• Comparación: Operadores para realizar comprobaciones.
• Binarios: Operadores a bajo nivel (a nivel de bits).

Operadores aritméticos

En primer lugar, vamos a centrarnos en los operadores aritméticos, que son los operadores que utilizamos para realizar operaciones matemáticas básicas. Los más sencillos son los cuatro primeros, que forman parte de las operaciones matemáticas básicas habituales:

Menos frecuentes suelen ser el módulo o la exponenciación, sin embargo, muy útiles en algunas situaciones.

Operador módulo

Observa el siguiente ejemplo donde utilizamos la operación módulo para limitar el índice:

const numbers = [10, 20, 30, 40, 50, 60, 70, 80];

for (let i = 0; i < numbers.length; i++) {
  const mod = i % 2;
  console.log(numbers[i], numbers[mod]);
}

Observa que en el console.log() estamos mostrando numbers[i] y luego numbers[mod]. Si ejecutas este código, comprobarás que en el primer caso, se van mostrando los valores del array numbers, es decir, 10, 20, 30... y así hasta 80. Sin embargo, en el segundo caso del console.log(), donde utilizamos mod como índice, se repiten los dos primeros: 10, 20, 10, 20, 10, 20....

Esto ocurre porque en la línea const mod = i % 2 hemos hecho el módulo sobre 2 y no estamos dejando que ese índice crezca más de 2, los valores que va a tomar mod en el bucle serán 0, 1, 0, 1, 0, 1..., puedes comprobarlo cambiando el console.log() y mostrando los valores i y mod.

Operador de exponenciación

En el caso de la exponenciación, simplemente podemos utilizar el operador **. Antiguamente, la exponenciación se hacía a través del método Math.pow(), sin embargo, ahora podemos hacerlo a través de este operador, con idéntico resultado:

const a = 2;
const b = 5;

console.log(Math.pow(a, b));    // 32
console.log(a ** b);            // 32
console.log(a * a * a * a * a); // 32

En este caso, estamos haciendo la operación 25, es decir, 2 * 2 * 2 * 2 * 2.

Operadores de asignación

Al margen de los anteriores, también tenemos los operadores de asignación. Estos operadores nos permiten asignar información a diferentes constantes o variables a través del símbolo =, lo cuál es bastante lógico pues así lo hacemos en matemáticas.

No obstante, también existen ciertas contracciones relacionadas con la asignación que nos permiten realizar operaciones de una forma más compacta. Son las siguientes:

Por ejemplo, realizar la asignación a = a + b sería exactamente lo mismo que escribir a += b, sólo que esta última está escrita de una forma más resumida.

Operadores unarios

Los operadores unarios son aquellos que en lugar de tener dos operandos, como los anteriores, sólo tienen uno. Es decir, se realizan sobre un sólo valor almacenado en una variable.

Una tarea muy común en programación es la de incrementar variables. Por ejemplo, si hacemos un a = a + 1, lo que estamos haciendo es incrementar el valor de a un número más grande del que ya poseía. Para hacer esto mucho más fácil y cómodo, podemos escribir a++ que es equivalente a lo anterior. Sin embargo, hay un pequeño matiz, que es lo que se denomina preincremento y postincremento.

Para ver las diferencias clave del preincremento y el postincremento observa el siguiente ejemplo:

let a = 0;

while (a < 5) {
  console.log(a, a++, a);
}

Observa que en el console.log() primero usamos la a, luego hacemos el postincremento (es decir, la usamos y luego incrementamos), y finalmente la volvemos a mostrar por consola. Prueba a reemplazar el a++ por ++a y hacer el mismo ejemplo. Esto nos dará el siguiente resultado:

a a++ a         a ++a a
- --- -         - --- -
0  0  1         0  1  1
1  1  2         1  2  2
2  2  3         2  3  3
3  3  4         3  4  4
4  4  5         4  5  5

Como puedes ver, en la segunda columna de la segunda tabla (preincremento), el valor mostrado ya ha sido incrementado, sin embargo, en la segunda columna de la primera tabla, permanece el valor (postincremento), ya que como su propio nombre indica se incrementará posteriormente.

Aunque estos detalles es bueno conocerlos, lo más habitual suele ser que se use el a++ en una línea independiente, sin utilizarse, por lo que no importa demasiado si hacer preincremento o postincremento. Sólo hay que tenerlo en cuenta si se está usando o asignando.

Operadores de comparación

Los operadores de comparación son aquellos que utilizamos en nuestro código (generalmente, en el interior de un if, aunque no es el único sitio donde podemos utilizarlos) para realizar comprobaciones. Estas expresiones de comparación devuelven un booleano con un valor de true o false.

Recuerda que en Javascript, hay diferencia entre == (igualdad) y === (identidad). Mientras que el primero sólo comprueba el valor de la comparación, el segundo comprueba el valor y el tipo de dato de la comparación. La diferencia se entiende muy fácil con el siguiente ejemplo:

5 == 5     // true   (ambos son iguales, coincide su valor)
"5" == 5   // true   (ambos son iguales, coincide su valor)
5 === 5    // true   (ambos son idénticos, coincide su valor y su tipo de dato)
"5" === 5  // false  (no son idénticos, coincide su valor, pero no su tipo de dato)

Operadores binarios

Aunque en Javascript no es algo que se utilice demasiado, existen los denominados operadores a nivel de bit. Se trata de una serie de operadores que nos permiten realizar operaciones básicas trabajando a nivel binario, donde los operandos solo pueden tomar valores de 0 o 1:

Por ejemplo, los tres primeros suelen ser los más habituales, donde podríamos crear las llamadas tablas de verdad, sin embargo, también podemos combinarlo con el NOT y conseguir variaciones:

 a   b     AND   OR    XOR     NOT AND   NOT OR   NOT XOR
--- ---   ----- ----- -----   --------- -------- ---------
 0   0      0     0     0         1         1        1
 0   1      0     1     1         1         0        0
 1   0      0     1     1         1         0        0
 1   1      1     1     0         0         0        1

Sin embargo, ten en cuenta que los operadores a nivel de bit son más complejos y pueden utilizarse en Javascript con valores diferentes de 0 y 1, por lo que necesitaríamos más conocimientos de como operar con números binarios y sus fundamentos.

Asignación a nivel de bit

De la misma forma que anteriormente vimos que tenemos a nuestra disposición unos operadores de asignación compactos para realizar tareas más verbosas, tenemos de la misma forma una serie de operadores de asignación a nivel de bit. Son los siguientes:

Existen muchos otros operadores, pero los veremos en la segunda parte de este artículo, donde explicamos operadores avanzados.