JS 03: Operadores Avanzados

Más allá de la suma y la resta: lógica y decisiones.

1. Operadores Aritméticos: La Calculadora

Son los símbolos que usas en matemáticas desde el colegio. JavaScript sabe sumar, restar, multiplicar y dividir. 

let suma = 5 + 3;        // 8

let resta = 10 - 4;      // 6

let multiplicacion = 3 * 4;  // 12

let division = 20 / 5;   // 4

let modulo = 10 % 3;     // 1 (Es el RESTO de la división)

1.1 Asignación con Operación (Ahorrando tiempo)

Los programadores somos vagos. Si podemos escribir menos, lo hacemos. Estas son las abreviaturas oficiales:

Símbolo Significado Ejemplo
+= Suma y asigna x += 5 es igual a x = x + 5
-= Resta y asigna x -= 1 es igual a x = x - 1
*= Multiplica y asigna x *= 2 es igual a x = x * 2
/= Divide y asigna x /= 2 es igual a x = x / 2

1.2 El Incremento: ++i vs i++ (Pre vs Post)

Ambos suman 1 a la variable, pero devuelven valores distintos en el momento de usarlos.

Post-incremento (i++)
"Usa el valor actual, y LUEGO suma". 
let i = 5;
let x = i++; 

// x vale 5 (valor original)
// i vale 6 (incrementado)
 Pre-incremento (++i)
"Suma primero, y LUEGO usa el nuevo valor". 
let i = 5;
let x = ++i; 

// x vale 6 (valor nuevo)
// i vale 6 (incrementado)

2. Comparación Estricta: ¿Gemelos o solo parecidos?

Aquí es donde muchos principiantes fallan. En JS hay dos formas de preguntar si algo es igual.

El Doble vs El Triple Igual

  • == (Igualdad débil): Es permisivo. Si comparas el número 5 con el texto "5", te dirá que son iguales. "Bueno, se parecen, te dejo pasar".
  • === (Igualdad estricta): Es exigente. Tienen que ser el mismo valor Y el mismo tipo de dato. "Tú eres un número y tú un texto. ¡No sois iguales!". 
// El peligro del doble igual

console.log(5 == "5");   // true (¡Mentira! Uno es texto)

console.log(0 == false); // true (¡Confuso!)



// La seguridad del triple igual (¡USA SIEMPRE ESTE!)

console.log(5 === "5");   // false (Correcto)

console.log(0 === false); // false (Correcto)

console.log(5 !== "5");   // true (Son diferentes)

3. Operadores Lógicos y "Cortocircuitos"

Además de combinar condiciones, los operadores lógicos tienen "trucos" muy usados en código profesional.

AND (&&) como Guardián

Si lo primero es falso, JS ni siquiera mira lo segundo. Se usa para ejecutar código solo si algo existe. 

let usuarioLogueado = true;

// Solo muestra el mensaje si está logueado

usuarioLogueado && console.log("Bienvenido al panel");

OR (||) como Valor por Defecto

Si lo primero es falso (o vacío), JS usa lo segundo. Ideal para rellenar datos que faltan.

let nombreUsuario = ""; // El usuario no puso nombre

let nombreMostrar = nombreUsuario || "Invitado"; 



console.log(nombreMostrar); // "Invitado"

4. El Operador Ternario: El "If" de una línea

Es una forma ultra-corta de escribir una condición if...else. Se usa muchísimo.

Estructura: ¿Condición? (Si es verdad) : (Si es mentira)

let edad = 20;



// Forma larga (If/Else)

let mensaje;

if (edad >= 18) {

    mensaje = "Es mayor de edad";

} else {

    mensaje = "Es menor";

}



// Forma Pro (Ternario)

let mensajeRapido = edad >= 18 ? "Es mayor de edad" : "Es menor";
Volver a JS