Tutorial JavaScript: Operadores

Los operadores en JavaScript son símbolos especiales que se utilizan para llevar a cabo operaciones entre variables y valores. Estos operadores pueden servir para realizar cálculos matemáticos, asignaciones, comparaciones, y manipulación de bits, entre otros. Dependiendo de la cantidad de operandos que requiera el operador, pueden ser clasificados en unarios, binarios o ternarios.

Operadores aritméticos

Permiten realizar operaciones matemáticas básicas, como suma, resta, multiplicación, división, etc.

let a = 10;
let b = 5;

let suma = a + b; // 15
let resta = a - b; // 5
let multiplicacion = a * b; // 50
let division = a / b; // 2
let modulo = a % b; // 0 (resto de la división)

Si se trabaja con valores de diferentes tipos (como un number y un string), los operadores de JavaScript intentan convertir uno o ambos valores al tipo más adecuado para realizar la operación. Este comportamiento es especialmente visible en operaciones aritméticas con cadenas de texto involucradas.

Si se suma (+) un número y una cadena, JavaScript convierte el número a una cadena y concatena las dos cadenas, en lugar de realizar una suma numérica. Por otro lado, el operador de multiplicación (*) intentaría convertir la cadena de texto en un número antes de realizar la operación. Es decir, si se aplica el operador de multiplicación entre un número y una cadena que contiene una representación textual de un número, JavaScript convierte automáticamente la cadena en un número y realiza la multiplicación numérica.

También es importante mencionar que si la cadena de texto no puede ser convertida en un número válido (por ejemplo, si contiene caracteres no numéricos), el resultado de la multiplicación será NaN (Not a Number), que representa un valor especial que indica que el resultado no es un número válido.

let a = 5;
let b = "10";
let c = a + b; // "510", ya que el número 5 es convertido en cadena y se concatena
let d = a * b; // 50, ya que la cadena "10" es convertida en número antes de la multiplicación

Operadores de asignación

Se utilizan para asignar valores a variables.

let x = 10; // Asignación básica

x += 5; // x = x + 5
x -= 3; // x = x - 3
x *= 2; // x = x * 2
x /= 2; // x = x / 2
x %= 3; // x = x % 3

Operadores de comparación

Sirven para comparar dos valores y devuelven un valor booleano (true o false) dependiendo del resultado de la comparación. Estos operadores pueden ser de igualdad, desigualdad, mayor o menor que, y otros.

let a = 10;
let b = 5;

a > b; // true (mayor que)
a < b; // false (menor que)
a >= b; // true (mayor o igual que)
a <= b; // false (menor o igual que)

Igualdad estricta (===) y no estricta (==)

El operador de igualdad estricta (===) compara si dos valores son iguales tanto en contenido como en tipo de dato. Si ambos valores tienen el mismo contenido y coinciden en el tipo de dato, el resultado de la comparación es verdadero (true). De lo contrario, será falso (false).

Por otro lado, el operador de igualdad no estricta (==) compara únicamente el contenido de los valores. Si ambos tienen el mismo contenido pero no coinciden en el tipo de dato, JavaScript realiza una conversión automática de tipos antes de llevar a cabo la comparación. Si tras dicha conversión, los valores son iguales, el resultado será verdadero (true). Caso contrario, será falso (false).

let a = 10; // tipo número
let b = "10"; // tipo cadena (string)

a === b; // false, ya que aunque el contenido es igual, el tipo de dato no coincide
a == b; // true, el contenido es igual y JavaScript convierte ambos valores al mismo tipo antes de realizar la comparación

Desigualdad estricta (!==) y no estricta (!=)

El operador de desigualdad estricta (!==) evalúa si dos valores son diferentes tanto en contenido como en tipo de dato. Si los valores son diferentes en contenido o tipo de dato, el resultado de la comparación será verdadero (true). De lo contrario, será falso (false).

Por el contrario, el operador de desigualdad no estricta (!=) compara solamente el contenido de los valores. Al igual que con la igualdad no estricta, JavaScript realiza una conversión automática de tipos en caso de ser necesario. Si tras la conversión los valores siguen siendo diferentes, el resultado será verdadero (true). Si no, será falso (false).

let a = 10; // tipo número
let b = "10"; // tipo cadena (string)

a !== b; // true, ya que aunque el contenido es igual, el tipo de dato no coincide
a != b; // false, el contenido es igual y JavaScript convierte ambos valores al mismo tipo antes de realizar la comparación

Operadores lógicos

Se utilizan para combinar dos o más condiciones y, como resultado, se obtiene un valor booleano (true o false) que indica si dichas condiciones se cumplen o no. Estos operadores son fundamentales a la hora de realizar evaluaciones complejas dentro de estructuras de control, como condicionales y bucles. Los principales operadores lógicos de JavaScript son: AND (&&), OR (||) y NOT (!).

AND (&&)

El operador AND (&&) es un operador binario que evalúa dos condiciones y devuelve verdadero (true) únicamente si ambas condiciones son verdaderas. Si alguna o ninguna de las condiciones es verdadera, el resultado será falso (false). Este operador se utiliza cuando se desea asegurar que todas las condiciones especificadas se cumplan simultáneamente.

let condicion1 = true;
let condicion2 = false;

let resultadoAND = condicion1 && condicion2; // false, ya que condicion2 es falso

OR (||)

El operador OR (||) también es un operador binario que evalúa dos condiciones y devuelve verdadero (true) si al menos una de las condiciones es verdadera. Si ninguna de las condiciones es verdadera, el resultado será falso (false). Este operador es útil cuando se desea que, al menos, alguna de las condiciones especificadas se cumpla.

let condicion1 = true;
let condicion2 = false;

let resultadoOR = condicion1 || condicion2; // true, ya que condicion1 es verdadero

NOT (!)

El operador NOT (!) es un operador unario que invierte el valor booleano de una condición. Es decir, si la condición original es verdadera (true), el resultado de aplicar el operador NOT será falso (false). Por el contrario, si la condición original es falso (false), el resultado será verdadero (true). Este operador se utiliza, por ejemplo, cuando se desea conocer si una condición específica no se cumple.

let condicion = true;

let resultadoNOT = !condicion; // false, ya que condicion es verdadero y ha sido invertido

Además, es posible combinar múltiples operadores lógicos en una misma expresión:

let condicion1 = true;
let condicion2 = false;
let condicion3 = true;

let resultado = condicion1 && (condicion2 || condicion3); // true, ya que condicion1 es verdadero y el resultado de (condicion2 || condicion3) también es verdadero

En este caso, es importante recordar que la precedencia de los operadores lógicos sigue el siguiente orden: NOT (!), AND (&&) y finalmente OR (||). Sin embargo, mediante el uso de paréntesis es posible alterar este orden y controlar el flujo de las evaluaciones.

Operadores condicionales (ternarios)

Son aquellos que toman tres operandos. El operador condicional está representado por el símbolo ? y tiene la siguiente sintaxis: condición ? valor_si_verdadero : valor_si_falso.

let a = 10;
let b = 5;

let max = (a > b) ? a : b; // 10 (si la condición a > b es verdadera, el resultado es a, de lo contrario, es b)

Operadores de cadena (string)

Permiten concatenar dos o más cadenas. El operador de concatenación es +.

let nombre = "Juan";
let apellido = "Pérez";

let nombreCompleto = nombre + " " + apellido; // "Juan Pérez"

Operadores de incremento y decremento

Sirven para incrementar o decrementar el valor de una variable en una unidad.

let contador = 1;

contador++; // incrementa en 1, contador ahora vale 2
contador--; // decrementa en 1, contador vuelve a valer 1

Operadores bitwise

Permiten realizar operaciones a nivel de bits, como desplazamiento de bits, AND, OR, XOR y NOT.

let x = 10; // 1010 en binario
let y = 12; // 1100 en binario

let bitAnd = x & y; // 1000 en binario, que es igual a 8 en decimal
let bitOr = x | y; // 1110 en binario, que es igual a 14 en decimal
let bitXor = x ^ y; // 0110 en binario, que es igual a 6 en decimal
let bitNot = ~x; // 0101 en binario (negación), que es igual a -11 en decimal
let leftshift = x << 2; // 101000 en binario, que es igual a 40 en decimal
let rightshift = x >> 2; // 0010 en binario, que es igual a 2 en decimal

Estos son los principales operadores de JavaScript, que permiten realizar una amplia gama de operaciones entre variables y valores. Cabe destacar que también existen operadores específicos para trabajar con objetos y arrays, pero los mencionados aquí son los fundamentales para el manejo de datos.