Operadores JavaScript: Guía Completa con Ejemplos
Los operadores JavaScript son símbolos especiales que realizan operaciones en valores o variables, conocidos como operandos. Estos operadores son esenciales para manipular datos, realizar cálculos y tomar decisiones en el código JavaScript. En esta guía completa, exploraremos los diferentes tipos de operadores en JavaScript, incluyendo su sintaxis, funcionamiento y ejemplos de uso.
Tipos de Operadores JavaScript
Los operadores JavaScript se clasifican en varios tipos, cada uno con su propia función y sintaxis. A continuación, analizaremos los tipos más comunes:
Operadores Aritméticos
Los operadores aritméticos se utilizan para realizar operaciones matemáticas básicas. Algunos de los operadores aritméticos más comunes incluyen:
- Suma (
+): Agrega dos operandos. - Resta (
-): Resta el segundo operando del primero. - Multiplicación (
*): Multiplica dos operandos. - División (
/): Divide el primer operando por el segundo. - Módulo (
%): Devuelve el residuo de la división de dos operandos.
Ejemplo:
«`javascript
let num1 = 10;
let num2 = 5;
// Suma
console.log(num1 + num2); // 15
// Resta
console.log(num1 – num2); // 5
// Multiplicación
console.log(num1 * num2); // 50
// División
console.log(num1 / num2); // 2
// Módulo
console.log(num1 % num2); // 0
«`
Operadores de Comparación
Los operadores de comparación se utilizan para comparar dos operandos y determinar su relación. Algunos de los operadores de comparación más comunes incluyen:
- Igualdad (
==): Verifica si dos operandos son iguales, realizando una conversión de tipo si es necesario. - Estrictamente igual (
===): Verifica si dos operandos son iguales y del mismo tipo sin realizar una conversión de tipo. - Desigualdad (
!=): Verifica si dos operandos son diferentes, realizando una conversión de tipo si es necesario. - Estrictamente desigual (
!==): Verifica si dos operandos son diferentes o de diferente tipo sin realizar una conversión de tipo. - Mayor que (
>): Verifica si el primer operando es mayor que el segundo. - Mayor o igual que (
>=): Verifica si el primer operando es mayor o igual que el segundo. - Menor que (
<): Verifica si el primer operando es menor que el segundo. - Menor o igual que (
<=): Verifica si el primer operando es menor o igual que el segundo.
Ejemplo:
«`javascript
let num1 = 10;
let num2 = 5;
// Igualdad
console.log(num1 == num2); // false
// Estrictamente igual
console.log(num1 === num2); // false
// Desigualdad
console.log(num1 != num2); // true
// Estrictamente desigual
console.log(num1 !== num2); // true
// Mayor que
console.log(num1 > num2); // true
// Mayor o igual que
console.log(num1 >= num2); // true
// Menor que
console.log(num1 < num2); // false
// Menor o igual que
console.log(num1 <= num2); // false
«`
Operadores Bit a Bit
Los operadores bit a bit operan sobre bits individuales de operandos enteros. Algunos de los operadores bit a bit más comunes incluyen:
- AND (
&): Realiza una operación AND bit a bit. - OR (
|): Realiza una operación OR bit a bit. - XOR (
^): Realiza una operación XOR bit a bit. - NOT (
~): Invierte los bits de un operando. - Desplazamiento a la izquierda (
<<): Desplaza los bits de un operando hacia la izquierda. - Desplazamiento a la derecha (
>>): Desplaza los bits de un operando hacia la derecha. - Desplazamiento a la derecha sin signo (
>>>): Desplaza los bits de un operando hacia la derecha sin signo.
Ejemplo:
«`javascript
let num1 = 10; // 1010 en binario
let num2 = 5; // 0101 en binario
// AND bit a bit
console.log(num1 & num2); // 0 en binario (0)
// OR bit a bit
console.log(num1 | num2); // 15 en binario (1111)
// XOR bit a bit
console.log(num1 ^ num2); // 15 en binario (1111)
// NOT bit a bit
console.log(~num1); // -11 en binario (10101111111111111111111111111001)
// Desplazamiento a la izquierda
console.log(num1 << 2); // 40 en binario (101000)
// Desplazamiento a la derecha
console.log(num1 >> 2); // 2 en binario (10)
// Desplazamiento a la derecha sin signo
console.log(num1 >>> 2); // 2 en binario (10)
«`
Operadores Lógicos
Los operadores lógicos se utilizan para combinar expresiones booleanas y evaluar su verdad o falsedad. Algunos de los operadores lógicos más comunes incluyen:
- AND (
&&): Devuelve true si ambas expresiones son true. - OR (
||): Devuelve true si al menos una de las expresiones es true. - NOT (
!): Invierte el valor de una expresión booleana.
Ejemplo:
«`javascript
let num1 = 10;
let num2 = 5;
// AND lógico
console.log(num1 > 5 && num2 < 10); // true
// OR lógico
console.log(num1 < 5 || num2 > 10); // false
// NOT lógico
console.log(!(num1 > 5)); // false
«`
Operadores de Asignación
Los operadores de asignación se utilizan para asignar un valor a una variable. El operador de asignación más común es el signo igual (=).
Ejemplo:
«`javascript
let num1 = 10;
let num2 = 5;
// Asignación simple
num1 = num2; // num1 ahora tiene el valor de 5
«`
Además del operador de asignación simple, JavaScript proporciona operadores de asignación combinados que realizan una operación aritmética y una asignación en un solo paso. Algunos de estos operadores incluyen:
- Suma y asignación (
+=): Agrega el segundo operando al primero y asigna el resultado al primer operando. - Resta y asignación (
-=): Resta el segundo operando del primero y asigna el resultado al primer operando. - Multiplicación y asignación (
*=): Multiplica el primer operando por el segundo y asigna el resultado al primer operando. - División y asignación (
/=): Divide el primer operando por el segundo y asigna el resultado al primer operando. - Módulo y asignación (
%=): Realiza la operación módulo y asigna el resultado al primer operando. - AND bit a bit y asignación (
&=): Realiza la operación AND bit a bit y asigna el resultado al primer operando. - OR bit a bit y asignación (
|=): Realiza la operación OR bit a bit y asigna el resultado al primer operando. - XOR bit a bit y asignación (
^=): Realiza la operación XOR bit a bit y asigna el resultado al primer operando. - Desplazamiento a la izquierda y asignación (
<<=): Desplaza los bits del primer operando hacia la izquierda y asigna el resultado al primer operando. - Desplazamiento a la derecha y asignación (
>>=): Desplaza los bits del primer operando hacia la derecha y asigna el resultado al primer operando. - Desplazamiento a la derecha sin signo y asignación (
>>>=): Desplaza los bits del primer operando hacia la derecha sin signo y asigna el resultado al primer operando.
Ejemplo:
«`javascript
let num1 = 10;
// Suma y asignación
num1 += 5; // num1 ahora tiene el valor de 15
// Resta y asignación
num1 -= 5; // num1 ahora tiene el valor de 10
// Multiplicación y asignación
num1 *= 2; // num1 ahora tiene el valor de 20
// División y asignación
num1 /= 2; // num1 ahora tiene el valor de 10
// Módulo y asignación
num1 %= 3; // num1 ahora tiene el valor de 1
«`
Operadores Especiales
JavaScript también incluye algunos operadores especiales que no encajan en las categorías anteriores. Algunos de estos operadores incluyen:
- Condicional (
?:): Evalúa una condición y devuelve uno de dos valores. - Acceso a miembros (
.): Acceder a las propiedades de un objeto. - Acceso a elementos de un array (
[]): Acceder a elementos específicos de un array. - Operador de coma (
,): Evalúa varias expresiones y devuelve el valor de la última expresión. - Operador de tipo (
typeof): Devuelve el tipo de un valor o variable. - Operador de instancia (
instanceof): Verifica si un objeto es una instancia de una clase. - Operador de eliminación (
delete): Elimina una propiedad de un objeto. - Operador de vacío (
void): Devuelve undefined.
Ejemplo:
«`javascript
let num1 = 10;
let num2 = 5;
// Condicional
let result = num1 > num2 ? «num1 es mayor» : «num2 es mayor»;
console.log(result); // «num1 es mayor»
// Acceso a miembros
let person = {
name: «John»,
age: 30
};
console.log(person.name); // «John»
// Acceso a elementos de un array
let numbers = [1, 2, 3, 4, 5];
console.log(numbers[2]); // 3
// Operador de coma
let num3 = (num1 + num2, num2 * 2);
console.log(num3); // 10
// Operador de tipo
console.log(typeof num1); // «number»
// Operador de instancia
let myArray = [1, 2, 3];
console.log(myArray instanceof Array); // true
// Operador de eliminación
delete person.age;
console.log(person.age); // undefined
// Operador de vacío
console.log(void 0); // undefined
«`
Consideraciones Importantes
- Prioridad de los operadores: Los operadores JavaScript tienen diferentes prioridades, lo que determina el orden en que se evalúan las expresiones. Las operaciones con mayor prioridad se evalúan primero.
- Asociatividad de los operadores: Los operadores JavaScript también tienen asociatividad, que determina cómo se evalúan las expresiones con la misma prioridad. La asociatividad puede ser de izquierda a derecha o de derecha a izquierda.
- Precedencia y asociatividad: Puedes consultar la documentación oficial de JavaScript para obtener una lista completa de las prioridades y asociatividades de los operadores JavaScript.
Conclusión
Los operadores JavaScript son herramientas esenciales para manipular datos, realizar cálculos y controlar el flujo del código. Comprender los diferentes tipos de operadores JavaScript y su funcionamiento es crucial para escribir código JavaScript eficiente y efectivo.