OPERADORES

OPERADORES DE ASIGNACIÓN
Operador
Nombre Significado
abreviado
1.Asignación x=y x=y
2. Asignación de adición x += y x=x+y
3. Asignación de resta x -= y x=x-y
4. Asignación de multiplicación x *= y x=x*y
5. Asignación de división x /= y x=x/y
6. Asignación de residuo x %= y x=x%y
7. Asignación de exponenciación x **= y x = x ** y
8. Asignación de desplazamiento a la izquierda x <<= y x = x << y
9. Asignación de desplazamiento a la derecha x >>= y x = x >> y
10. Asignación de desplazamiento a la derecha sin signo x >>>= y x = x >>> y
11. Asignación AND bit a bit x &= y x=x&y
12. Asignación XOR bit a bit x ^= y x=x^y
13. Asignación OR bit a bit x |= y x=x|y
14. Asignación AND lógico x &&= y x && (x = y)
15. Asignación OR lógico x ||= y x || (x = y)
16. Asignación de anulación lógica x ??= y x ?? (x = y)

6. Asignación de residuo ( x %= y ): Calcula el residuo de la división de x entre y y

asigna el resultado a x .

let x = 10;
x %= 3; // es equivalente a x = x % 3, y ahora x vale 1 (residuo de 10 dividido
por 3)

7. Asignación de exponenciación ( x **= y ): Calcula x elevado a la potencia y y

asigna el resultado a x .

let x = 2;
x **= 3; // es equivalente a x = x ** 3, y ahora x vale 8 (2 elevado a la
potencia 3)

8. Asignación de desplazamiento a la izquierda ( x <<= y ): Desplaza los bits de x

hacia la izquierda y veces y asigna el resultado a x .
let x = 8; // en binario: 1000
x <<= 2; // es equivalente a x = x << 2, y ahora x vale 32 (desplazamiento de 2
bits a la izquierda)

9. Asignación de desplazamiento a la derecha ( x >>= y ): Desplaza los bits de x hacia

la derecha y veces y asigna el resultado a x .

let x = 32; // en binario: 100000

x >>= 2; // es equivalente a x = x >> 2, y ahora x vale 8 (desplazamiento de 2
bits a la derecha)

10. Asignación de desplazamiento a la derecha sin signo ( x >>>= y ): Desplaza los bits
de x hacia la derecha y veces sin tener en cuenta el signo y asigna el resultado a x .

let x = -8; // en binario (suponiendo 32 bits):

11111111111111111111111111111000
x >>>= 2; // es equivalente a x = x >>> 2, y ahora x vale 1073741822
(desplazamiento de 2 bits a la derecha sin signo)

11. Asignación AND bit a bit ( x &= y ): Realiza una operación AND bit a bit entre x y
y y asigna el resultado a x .

let x = 5; // en binario: 101

let y = 3; // en binario: 011
x &= y; // es equivalente a x = x & y, y ahora x vale 1 (resultado de la
operación AND bit a bit)

12. Asignación XOR bit a bit ( x ^= y ): Realiza una operación XOR bit a bit entre x y
y y asigna el resultado a x .

let x = 5; // en binario: 101

let y = 3; // en binario: 011
x ^= y; // es equivalente a x = x ^ y, y ahora x vale 6 (resultado de la
operación XOR bit a bit)

13. Asignación OR bit a bit ( x |= y ): Realiza una operación OR bit a bit entre x y y y
asigna el resultado a x .

let x = 5; // en binario: 101

let y = 3; // en binario: 011
x |= y; // es equivalente a x = x | y, y ahora x vale 7 (resultado de la
operación OR bit a bit)
 14. Asignación AND lógico ( x &&= y ): Evalúa la expresión x && (x = y) y asigna
el valor de y a x si la expresión es verdadera.

let x = true;
let y = false;
x &&= y; // es equivalente a x && (x = y), y ahora x vale false

15. Asignación OR lógico ( x ||= y ): Evalúa la expresión x || (x = y) y asigna el

valor de y a x si la expresión es falsa.

let x = false;
let y = true;
x ||= y; // es equivalente a x || (x = y), y ahora x vale true

16. Asignación de anulación lógica ( x ??= y ): Evalúa la expresión x ?? (x = y) y

asigna el valor de y a x si x es nulo o indefinido.

let x = null;
let y = "valor";
x ??= y; // es equivalente a x ?? (x = y), y ahora x vale "valor"

OPERADORES DE COMPARACIÓN

Ejemplos que
Operador Descripción
devuelven true
3 == var1
Igual (==) Devuelve true si los operandos son iguales. "3" == var1
3 == '3'
var1 != 4
No es igual (!=) Devuelve true si los operandos no son iguales.
var2 != "3"
Devuelve true si los operandos son iguales y del
Estrictamente igual
mismo tipo. Consulta también Object.is y similitud en 3 === var1
(===)
JS.
Desigualdad estricta Devuelve true si los operandos son del mismo tipo var1 !== "3"
(!==) pero no iguales, o son de diferente tipo. 3 !== '3'
Devuelve true si el operando izquierdo es mayor que
Mayor que (>) var2 > var1 "12" > 2
el operando derecho.
Mayor o igual que Devuelve true si el operando izquierdo es mayor o var2 >= var1 var1 >=
(>=) igual que el operando derecho. 3
Devuelve true si el operando izquierdo es menor que var1 < var2
Menor que (<)
el operando derecho. "2" < 12
Menor o igual que Devuelve true si el operando izquierdo es menor o var1 <= var2 var2 <=
(<=) igual que el operando derecho. 5
 OPERADORES ARITMÉTICOS

Operador Descripción Ejemplo

Operador binario. Devuelve el resto entero
Residuo (%) 12 % 5 devuelve 2.
de dividir los dos operandos.
Operador unario. Agrega uno a su
operando. Cuando utilizas --x , el Si x es 3, ++x establece x en 4
y devuelve 4, mientras que x++
Incremento (++) incremento se aplica antes de devolver el
devuelve 3 y , solo entonces,
valor, mientras que con x-- , el incremento establece x en 4.
se aplica después de devolver el valor.
Operador unario. Resta uno de su
operando. El valor de retorno es análogo al
del operador de incremento. Cuando Si x es 3, entonces --x
utilizas --x , el decremento se aplica antes establece x en 2 y devuelve 2,
Decremento (--)
mientras que x-- devuelve 3 y,
de devolver el valor, mientras que con x-- , solo entonces, establece x en 2.
el decremento se aplica después de
devolver el valor.
Operador unario. Devuelve la negación de Si x es 3, entonces -x devuelve
Negación unaria (-)
su operando. -3.
Operador unario. Intenta convertir el +"3" devuelve 3. +true
Positivo unario (+)
operando en un número, si aún no lo es. devuelve 1.
Calcula la base a la potencia de exponente,
Operador de 2 ** 3 returns 8. 10 ** -1
es decir, baseexponente2 ** 3 returns 8. 10
exponenciación (**) returns 0.1.
** -1 returns 0.1.

OPERADORES BIT A BIT

Operador
AND a nivel de bits
OR a nivel de bits
XOR a nivel de bits
NOT a nivel de bits
Desplazamiento a la izquierda a << b
Desplazamiento a la derecha de
propagación de signo
Desplazamiento a la derecha de
relleno cero
Uso Descripción
Devuelve un uno en cada posición del bit para los que
a&b
los bits correspondientes de ambos operandos son unos.
Devuelve un cero en cada posición de bit para el cual
a|b
los bits correspondientes de ambos operandos son ceros.
Devuelve un cero en cada posición de bit para la que los
bits correspondientes son iguales. [Devuelve uno en
a^b
cada posición de bit para la que los bits
correspondientes son diferentes].
~a Invierte los bits de su operando.
Desplaza a en representación binaria b bits hacia la
izquierda, desplazándose en ceros desde la derecha.
Desplaza a en representación binaria b bits a la derecha,
a >> b
descartando los bits desplazados.
Desplaza a en representación binaria b bits hacia la
a >>> b derecha, descartando los bits desplazados y
desplazándose en ceros desde la izquierda.

OPERADORES DE DESPLAZAMIENTO DE BITS

Operador Descripción Ejemplo
Este operador desplaza el
primer operando el número
especificado de bits a la 9<<2 produce 36, porque 1001
Desplazamiento a la
izquierda. Los bits desplazados desplazado 2 bits a la izquierda se
izquierda (<<)
en exceso hacia la izquierda se convierte en 100100, que es 36.
descartan. Los bits cero se
desplazan desde la derecha.
Este operador desplaza el
primer operando el número
9>>2 produce 2, porque 1001
especificado de bits a la
Desplazamiento a la desplazado 2 bits a la derecha se
derecha. Los bits desplazados
derecha de propagación convierte en 10, que es 2. Del mismo
en exceso hacia la derecha se
de signo (>>) modo, -9>>2 produce -3, porque el
descartan. Las copias del bit
signo se conserva.
más a la izquierda se desplazan
desde la izquierda.
19>>>2 produce 4, porque 10011
Este operador desplaza el
desplazado 2 bits a la derecha se
primer operando el número
convierte en 100, que es 4. Para
Desplazamiento a la especificado de bits a la
números no negativos, el
derecha de relleno derecha. Los bits desplazados
desplazamiento a la derecha de relleno
cero(>>>) en exceso hacia la derecha se
con ceros y el desplazamiento a la
descartan. Los bits cero se
derecha de propagación del signo
desplazan desde la izquierda.
producen el mismo resultado.
OPERADORES LÓGICOS
Operador Uso Descripción
Devuelve expr1 si se puede convertir a false; de lo contrario, devuelve
AND Lógico expr1 &&
expr2. Por lo tanto, cuando se usa con valores booleanos, && devuelve
(&&) expr2
true si ambos operandos son true; de lo contrario, devuelve false.
Devuelve expr1 si se puede convertir a true; de lo contrario, devuelve
OR lógico expr2. Por lo tanto, cuando se usa con valores booleanos, || devuelve
expr1 || expr2
(||) true si alguno de los operandos es true; si ambos son falsos, devuelve
false.
NOT lógico Devuelve false si su único operando se puede convertir a true; de lo
!expr
(!) contrario, devuelve true.

OPERADORES DE CADENA

Además de los operadores de comparación, que se pueden usar en valores de cadena, el operador
de concatenación (+) concatena dos valores de cadena, devolviendo otra cadena que es la unión de
los dos operandos de cadena.

console.log('mi ' + 'cadena'); // la consola registra la cadena "mi cadena".

El operador de asignación abreviada += también se puede utilizar para concatenar cadenas.

var mystring = 'alpha';

mystring += 'bet'; // se evalúa como "alphabet" y asigna este valor a mystring.

OPERADOR CONDICIONAL TERNARIO

El operador condicional es el único operador de JavaScript que toma tres operandos. El

operador puede tener uno de dos valores según una condición. La sintaxis es:

condition ? val1 : val2

Si condition es true, el operador tiene el valor de val1. De lo contrario, tiene el valor de val2.
Puedes utilizar el operador condicional en cualquier lugar donde normalmente utilizas un operador
estándar. Por ejemplo:

var status = (age >= 18) ? 'adult' : 'minor';

Esta declaración asigna el valor "adult" a la variable status si age es de dieciocho años o más. De lo
contrario, asigna el valor "minor" a status.
OPERADOR COMA

El operador coma en JavaScript se utiliza para evaluar múltiples expresiones, separadas por comas,
y devuelve el valor de la última expresión. Por ejemplo:
let a = 1, b = 2, c = 3;
let resultado = (a++, b++, c++);
console.log(resultado); // Muestra 3

En cada expresión, el operador ++ incrementa el valor de la variable correspondiente en 1. Por lo

tanto, al finalizar la evaluación, a será igual a 2, b será igual a 3 y c será igual a 4. Sin embargo,
el valor devuelto por el operador coma es el resultado de la última expresión evaluada, que es 3 (el
valor original de c antes del incremento).

El operador coma también puede ser útil en contextos como la inicialización de variables en una
declaración for o la especificación de argumentos en una llamada a una función que espera
múltiples argumentos.

1. Inicialización de variables en una declaración for :

for (let i = 0, j = 10; i < j; i++, j--) {

// Cuerpo del bucle
}
En este ejemplo, se utiliza el operador coma para inicializar dos variables i y j en la declaración
for . La primera expresión let i = 0, j = 10 utiliza el operador coma para separar las dos
declaraciones de variable. Así, se pueden declarar e inicializar múltiples variables en una sola línea
antes de que el bucle comience a ejecutarse.

2. Especificación de argumentos en una llamada a una función:

function sumar(a, b, c) {
return a + b + c;
}
let resultado = sumar(1, 2, 3);
console.log(resultado); // Muestra 6
En este ejemplo, se utiliza el operador coma para especificar múltiples argumentos en una llamada a
la función sumar() . La función sumar() espera tres argumentos a , b y c . Mediante el uso
del operador coma, se pueden proporcionar los tres argumentos en una sola llamada separada por
comas.

OPERADORES UNARIOS
1. El operador delete se utiliza para eliminar una propiedad de un objeto o para eliminar un
elemento de un arreglo. Su sintaxis es la siguiente:
delete objeto.propiedad; // Elimina una propiedad de un objeto
delete arreglo[indice]; // Elimina un elemento de un arreglo
 1. Eliminar una propiedad de un objeto: Cuando se utiliza el operador delete en un
objeto para eliminar una propiedad, el operador devuelve true si la eliminación es exitosa
y false si no es posible eliminar la propiedad (por ejemplo, si la propiedad es no
configurable).

let objeto = {
propiedad1: "valor1",
propiedad2: "valor2"
};
console.log(objeto); // Muestra { propiedad1: "valor1", propiedad2: "valor2" }
delete objeto.propiedad1;
console.log(objeto); // Muestra { propiedad2: "valor2" }

2. Eliminar un elemento de un arreglo: Al utilizar el operador delete en un arreglo

para eliminar un elemento, el elemento se reemplaza por undefined . Sin embargo, el
tamaño del arreglo no cambia y se mantiene el número de índices.

let arreglo = [1, 2, 3, 4, 5];

console.log(arreglo); // Muestra [1, 2, 3, 4, 5]
delete arreglo[2];
console.log(arreglo); // Muestra [1, 2, undefined, 4, 5]

En este ejemplo, se utiliza el operador delete para eliminar el elemento en el índice 2 del arreglo.
El elemento se reemplaza por undefined , pero el tamaño del arreglo no cambia. Es importante tener
en cuenta que el operador delete solo puede eliminar propiedades de objetos que sean configurables
y no puede eliminar variables ni propiedades de alcance léxico (variables declaradas con var , let o
const fuera de un objeto). Dado que los arreglos solo son objetos, técnicamente es posible delete
elementos de ellos. Sin embargo, esto se considera una mala práctica, trata de evitarlo. Cuando
eliminas una propiedad de arreglo, la longitud del arreglo no se ve afectada y otros elementos no se
vuelven a indexar. Para lograr ese comportamiento, es mucho mejor simplemente sobrescribir el
elemento con el valor undefined. Además, en el caso de los arreglos, es más común utilizar el
método splice() para eliminar elementos, ya que ajusta automáticamente el tamaño del arreglo.

2. El operador typeof se utiliza para determinar el tipo de dato de una expresión. Devuelve una
cadena de texto que representa el tipo de dato de la expresión evaluada. La sintaxis es la siguiente:
typeof expresion

El operador typeof es útil para realizar comprobaciones de tipos o tomar decisiones basadas en el
tipo de dato de una expresión. . Aquí tienes algunos ejemplos para ilustrar su uso:
console.log(typeof 42); // Muestra "number"
console.log(typeof "Hola"); // Muestra "string"
console.log(typeof true); // Muestra "boolean"
console.log(typeof [1, 2, 3]); // Muestra "object"
console.log(typeof { nombre: "Juan", edad: 30 }); // Muestra "object"
console.log(typeof undefined); // Muestra "undefined"
console.log(typeof null); // Muestra "object" (un error histórico en JavaScript)
console.log(typeof function() {}); // Muestra "function"
console.log(typeof parseInt); // Muestra "function"
console.log(typeof shape.split); // Muestra "function"

3. El operador void se utiliza para evaluar una expresión y devolver undefined . Se coloca
antes de la expresión que se desea evaluar. Su sintaxis es la siguiente:
void expresion
El uso más común del operador void es cuando se desea ejecutar una función o acción que no
devuelve un valor útil, como una redirección a una página web sin esperar una respuesta. Por
ejemplo:
<a href="https://www.example.com" onclick="void 0">Haz clic aquí</a>
En este ejemplo, cuando se hace clic en el enlace, se evalúa la expresión void 0 , lo que hace que
no se realice ninguna acción específica.

Es importante destacar que el operador void no cambia la expresión original ni tiene un uso muy
extendido en la programación diaria. Se utiliza principalmente en casos específicos donde se
necesita evitar que la expresión tenga un efecto no deseado.

OPERADORES RELACIONALES

1. El operador in se utiliza para verificar si una propiedad específica existe en un objeto. Permite
determinar si un objeto tiene una propiedad con un nombre específico, ya sea propia del objeto o
heredada de su cadena de prototipos.

La sintaxis del operador in es la siguiente: propiedad in objeto

El operador in devuelve un valor booleano, es decir, true si la propiedad existe en el objeto y false
si no existe. Veamos un ejemplo:
const persona = {
nombre: 'Juan',
edad: 30
};
console.log('nombre' in persona); // Muestra true
console.log('apellido' in persona); // Muestra false

El operador in también se puede utilizar en estructuras de control, como el condicional if , para

realizar acciones basadas en la existencia de una propiedad en un objeto:
const persona = {
nombre: 'Juan',
edad: 30 };
if ('nombre' in persona) {
console.log('La propiedad nombre existe en el objeto persona.');
} else {
console.log('La propiedad nombre no existe en el objeto persona.'); }

2. El operador instanceof se utiliza para comprobar si un objeto pertenece a una determinada

clase o constructor. Permite verificar si un objeto es una instancia de una clase específica o de
alguna de sus subclases.
La sintaxis del operador instanceof es la siguiente: objeto instanceof Clase
El operador instanceof devuelve un valor booleano, es decir, true si el objeto es una instancia de la
clase o constructor especificado, y false si no lo es.

PRECEDENCIA DE LOS OPERADORES

La precedencia de los operadores determina el orden en que se aplican al evaluar una expresión.
Puedes redefinir la precedencia de los operadores mediante el uso de paréntesis.

Tipo de operador Operadores individuales

miembro . []
llamar / crear instancia () new
Tipo de operador Operadores individuales
negación / incremento ! ~ - + ++ -- typeof void delete
multiplicar / dividir */%
adición / sustracción +-
desplazamiento bit a bit << >> >>>
relacional < <= > >= in instanceof
igualdad == != === !==
AND bit a bit &
XOR bit a bit ^
OR bit a bit |
AND lógico &&
OR lógico ||
condicional ?:
asignación = += -= *= /= %= <<= >>= >>>= &= ^= |= &&= ||= ??=
coma ,

ÍNDICE

Operadores de asignación………………………………………………………..…….………...1-3
Operadores de comparación………………………………………………………………….…….3
Operadores aritméticos……………………………………………………………………….…….4
Operadores bit a bit y de desplazamiento de bits…………………………………………….…….5
Operadores lógicos………………………………………………………………………….……...6
Operadores de cadena……………………………………………………………………….……...6
Operador condicional ternario…………………………………………………………….………..6
Operador coma……………………………………………………………………….…………….7
Operadores unarios…………………………………………………………….………………....8-9
Operadores relacionales……………………………………………………………………….…..10
Precedencia de operadores…………………………………………………………………….......11
OPERADORES