Operadores de Asignación en JavaScript
Los operadores de asignación se utilizan para asignar valores a las variables en JavaScript. El más básico es = , pero existen muchos otros que combinan operaciones aritméticas, lógicas y de asignación para facilitar la escritura del código.
script.js
let x = 10;
// Asignación simple
x = 20;
console.log("Asignación simple:", x); // Muestra: 20
// Suma y asignación
x += 5;
console.log("Suma y asignación:", x); // Muestra: 25
// Resta y asignación
x -= 10;
console.log("Resta y asignación:", x); // Muestra: 15
// Multiplicación y asignación
x *= 2;
console.log("Multiplicación y asignación:", x); // Muestra: 30
// División y asignación
x /= 3;
console.log("División y asignación:", x); // Muestra: 10
// Módulo y asignación
x %= 4;
console.log("Módulo y asignación:", x); // Muestra: 2
// Exponenciación y asignación
x **= 3;
console.log("Exponenciación y asignación:", x); // Muestra: 8
Tipos de operadores de asignación en JavaScript
| Operador | Nombre | Ejemplo | Descripción |
|---|---|---|---|
= | Asignación simple | a = 5 | Asigna el valor de la derecha a la variable de la izquierda. |
+= | Asignación con suma | a += 5 | Suma el valor actual con el de la derecha y lo asigna. |
-= | Asignación con resta | a -= 5 | Resta el valor de la derecha al actual y lo asigna. |
*= | Asignación con multiplicación | a *= 5 | Multiplica el valor actual con el de la derecha y lo asigna. |
/= | Asignación con división | a /= 5 | Divide el valor actual entre el de la derecha y lo asigna. |
%= | Asignación con módulo | a %= 5 | Calcula el resto de la división y lo asigna. |
**= | Asignación con exponenciación | a **= 2 | Eleva el valor actual a la potencia del valor de la derecha. |
<<= | Asignación con desplazamiento a la izquierda | a <<= 2 | Desplaza los bits del valor actual a la izquierda. |
>>= | Asignación con desplazamiento a la derecha | a >>= 2 | Desplaza los bits del valor actual a la derecha. |
&= | Asignación AND bit a bit | a &= 2 | Realiza un AND binario entre los valores. |
| ` | =` | Asignación OR bit a bit | `a |
^= | Asignación XOR bit a bit | a ^= 2 | Realiza un XOR binario entre los valores. |
1. Asignación simple (=)
Asigna directamente un valor a una variable.
let a = 10;
console.log(a); // Muestra: 10
2. Asignación combinada: suma (+=)
Suma un valor al actual y asigna el resultado a la misma variable.
let a = 10;
a += 5; // a = a + 5
console.log(a); // Muestra: 15
3. Asignación combinada: resta (-=)
Resta un valor al actual y asigna el resultado a la misma variable.
let a = 20;
a -= 4; // a = a - 4
console.log(a); // Muestra: 16
4. Asignación combinada: multiplicación (*=)
Multiplica un valor por el actual y asigna el resultado.
let a = 7;
a *= 3; // a = a * 3
console.log(a); // Muestra: 21
5. Asignación combinada: división (/=)
Divide el valor actual entre el de la derecha y asigna el resultado.
let a = 50;
a /= 10; // a = a / 10
console.log(a); // Muestra: 5
6. Asignación combinada: módulo (%=)
Calcula el resto de la división y asigna el resultado.
let a = 17;
a %= 5; // a = a % 5
console.log(a); // Muestra: 2
7. Asignación combinada: exponenciación (**=)
Eleva el valor actual a una potencia y asigna el resultado.
let a = 2;
a **= 3; // a = a ** 3
console.log(a); // Muestra: 8
Ventajas de los operadores combinados
🔸Código más corto: Reducen la repetición en las expresiones.
🔸Fácil de leer: Facilitan la comprensión de operaciones frecuentes como += o *= .
🔸Eficiencia: Evitan escribir pasos intermedios.
let resultado = 5 + 3 * 2; // Multiplicación se evalúa primero
console.log(resultado); // Muestra: 11
let resultadoConParentesis = (5 + 3) * 2; // Paréntesis primero
console.log(resultadoConParentesis); // Muestra: 16
Ejercicio Práctico
-
Declara una variable con el valor
50. Usa operadores de asignación para:- Sumarle
10. - Restarle
5. - Multiplicarla por
2. - Dividirla entre
4. - Calcular el resto al dividirla por
3.
- Sumarle
-
Crea una variable inicializada en
8. Usa el operador de exponenciación (**=) para elevarla al cubo y muestra el resultado. -
Usa operadores de desplazamiento bit a bit (
<<=,>>=) para modificar una variable inicializada en4.