Los operadores en JavaScript son símbolos o palabras que le dicen al lenguaje que realice alguna operación sobre uno o más valores. Estos operadores permiten manipular datos, realizar cálculos, comparar valores, y mucho más.

Tipos principales de operadores

1. Operadores Aritméticos:

   • + (Suma): Suma dos números o concatena cadenas de texto.

      
     1let suma = 5 + 3; // 8
     2let texto = "Hola, " + "mundo!"; // "Hola, mundo!"
     3console.log(texto);
     Salida de Consola!:
     Hola, mundo!

   • - (Resta): Resta un número de otro.

      
     1let resta = 10 - 4; // 6
     2console.log(resta);
     Salida de Consola!:
     6

   • * (Multiplicación): Multiplica dos números.

      
     1let multiplicacion = 6 * 7; // 42
     2console.log(multiplicacion);
     Salida de Consola!:
     42

   • / (División): Divide un número entre otro.

      
     1let division = 5 / 2; // 2.5
     2console.log(division);
     Salida de Consola!:
     2.5

   • % (Módulo): Devuelve el resto de la división entre dos números.

      
     1let resto = 10 % 3; // 1
     2console.log(resto);
     Salida de Consola!:
     1

   • ** (Exponenciación): Eleva un número a la potencia de otro.

      
     1let potencia = 2 ** 3; // 8
     2console.log(potencia);
     Salida de Consola!:
     8

2. Operadores de Asignación:

   • =: Asigna un valor a una variable.

      
     1let x = 10;
     2console.log(x);
     Salida de Consola!:
     10

   • +=: Suma y asigna.

      
     1let x = 10;
     2x += 5; // x ahora es 15
     3console.log(x);
     Salida de Consola!:
     15

   • -=: Resta y asigna.

      
     1let x = 10;
     2x -= 3; // x ahora es 7
     3console.log(x);
     Salida de Consola!:
     7

   • *=: Multiplica y asigna.

      
     1let x = 10;
     2x *= 2; // x ahora es 20
     3console.log(x);
     Salida de Consola!:
     20

   • /=: Divide y asigna.

      
     1let x = 24;
     2x /= 4; // x ahora es 6
     3console.log(x);
     Salida de Consola!:
     6

   • %=: Calcula el módulo y asigna.

      
     1let x = 26;
     2x %= 5; // x ahora es 1 
     3console.log(x);
     Salida de Consola!:
     1

3. Operadores de Comparación:

   • ==: Compara si dos valores son iguales (sin tener en cuenta el tipo).

      
     1let esIgual = 5 == "5"; // true
     2console.log(esIgual);
     Salida de Consola!:
     true

   • ===: Compara si dos valores son estrictamente iguales (considera el tipo).

      
     1let esEstrictamenteIgual = 5 === "5"; // false
     2console.log(esEstrictamenteIgual);
     Salida de Consola!:
     false

   • !=: Compara si dos valores son diferentes.

      
     1let esDiferente = 5 != "5"; // false
     2console.log(esDiferente);
     Salida de Consola!:
     false

   • !==: Compara si dos valores son estrictamente diferentes.

      
     1let esEstrictamenteDiferente = 5 !== "5"; // true
     2console.log(esEstrictamenteDiferente);
     Salida de Consola!:
     true

   • >: Compara si un valor es mayor que otro.

      
     1let esMayor = 10 > 5; // true
     2console.log(esMayor);
     Salida de Consola!:
     true

   • <: Compara si un valor es menor que otro.

      
     1let esMenor = 3 < 8; // true
     2console.log(esMenor);
     Salida de Consola!:
     true

   • >=: Compara si un valor es mayor o igual que otro.

      
     1let esMayorOIgual = 6 >= 6; // true
     2console.log(esMayorOIgual);
     Salida de Consola!:
     true

   • <=: Compara si un valor es menor o igual que otro.

      
     1let esMenorOIgual = 7 <= 9; // true
     2console.log(esMenorOIgual);
     Salida de Consola!:
     true

4. Operadores Lógicos:

   • && (Y lógico): Devuelve true si ambas condiciones son verdaderas.

      
     1let yLogico = (5 > 3) && (8 > 6); // true
     2console.log(yLogico);
     Salida de Consola!:
     true

   • || (O lógico): Devuelve true si al menos una condición es verdadera.

      
     1let oLogico = (5 > 3) || (8 < 6); // true
     2console.log(oLogico);
     Salida de Consola!:
     true

   • ! (No lógico): Invierte el valor lógico de una condición.

      
     1let noLogico = !(5 > 3); // false
     2console.log(noLogico);
     Salida de Consola!:
     false

5. Operadores de Incremento/Decremento:

   • ++ (Incremento): Aumenta el valor de una variable en 1.

      
     1let num = 5;
     2num++; // num ahora es 6
     3console.log(num);
     Salida de Consola!:
     6

   • -- (Decremento): Disminuye el valor de una variable en 1.

      
     1let num = 5;
     2num--; // num ahora es 4
     3console.log(num);
     Salida de Consola!:
     4

6. Operadores de Concatenación:

   • +: Además de sumar, este operador puede concatenar (unir) cadenas de texto.

      
     1let texto = "Hola, " + "mundo!"; // "Hola, mundo!"
     2console.log(texto);
     Salida de Consola!:
     Hola, mundo!

Resumen

Los operadores son esenciales en JavaScript para realizar cálculos, tomar decisiones, y manipular datos. Entender cómo y cuándo usar cada operador te permitirá escribir código más efectivo y eficiente.