Operadores básicos y expresiones

Operadores aritméticos

Los operadores aritméticos son los más intuitivos porque funcionan igual que en matemáticas básicas. Se utilizan para realizar cálculos numéricos.

Ejemplos prácticos en código

// Suma simple
let manzanas = 5;
let naranjas = 3;
let totalFrutas = manzanas + naranjas;
console.log(totalFrutas); // 8

// Módulo: muy útil para saber si un número es par o impar
let numero = 17;
console.log(numero % 2); // 1 (impar, porque queda resto 1)

// Exponenciación: calcular áreas y potencias
let lado = 5;
let areaCuadrado = lado ** 2;
console.log(areaCuadrado); // 25

Operadores de asignación

Los operadores de asignación asignan valores a las variables. El más básico es =, pero existen operadores combinados que realizan una operación y asignación al mismo tiempo.

let puntos = 100;

// Aumentar puntos
puntos += 50; // Ahora puntos es 150

// Reducir puntos por penalización
puntos -= 20; // Ahora puntos es 130

// Doblar puntos por bonificación especial
puntos *= 2; // Ahora puntos es 260

console.log(puntos); // 260

Operadores de incremento y decremento

JavaScript ofrece operadores especiales para aumentar o disminuir una variable en exactamente 1:

let edad = 25;

// Pre-incremento: primero incrementa, luego usa el valor
console.log(++edad); // 26

// Post-incremento: primero usa el valor, luego incrementa
console.log(edad++); // 26 (imprime 26, pero edad ya es 27)
console.log(edad);   // 27

// Decremento funciona igual pero resta 1
let vidas = 3;
console.log(--vidas); // 2

Operadores de comparación

Los operadores de comparación evalúan si una condición es verdadera o falsa, devolviendo siempre un valor booleano (true o false).

// Comparación relajada (==) - JavaScript convierte tipos
console.log(5 == "5");   // true (string "5" se convierte a número)
console.log(true == 1);  // true
console.log(false == 0); // true

// Comparación estricta (===) - NO convierte tipos
console.log(5 === "5");   // false (son tipos diferentes)
console.log(true === 1);  // false

// En la práctica, SIEMPRE usa === y !==
let password = "abc123";
let inputUsuario = "abc123";

// ✅ CORRECTO - Comparación estricta
if (password === inputUsuario) {
  console.log("Acceso concedido");
}

// ❌ EVITAR - Comparación relajada (puede causar errores)
if (password == inputUsuario) {
  // Funciona, pero es mala práctica
}

Operadores lógicos

Los operadores lógicos combinan múltiples condiciones booleanas para crear expresiones más complejas.

let edad = 22;
let tieneDinero = true;
let tieneIdentidad = true;

// AND: todas las condiciones deben cumplirse
if (edad >= 18 && tieneDinero && tieneIdentidad) {
  console.log("Puedes comprar alcohol");
}

// OR: al menos una condición debe cumplirse
let esFinDeSemana = true;
let estaDeVacaciones = false;

if (esFinDeSemana || estaDeVacaciones) {
  console.log("Puedes dormir hasta tarde");
}

// NOT: invierte la condición
let usuarioBloqueado = false;
if (!usuarioBloqueado) {
  console.log("Bienvenido al sistema");
}

// Combinación de operadores lógicos
let esMayorDeEdad = edad >= 18;
let tieneLicencia = true;

if (esMayorDeEdad && (tieneDinero || tieneLicencia)) {
  console.log("Puedes rentar un auto");
}

// Con ||, si el primer valor es "truthy", lo devuelve sin evaluar el segundo
let nombre = "Carlos" || "Anónimo"; // Devuelve "Carlos"

// Si el primer valor es "falsy", devuelve el segundo
let apelido = "" || "Anónimo"; // Devuelve "Anónimo"

// Con &&, si el primer valor es "falsy", lo devuelve sin evaluar el segundo
let resultado = false && "esto no se ejecutará"; // Devuelve false

// Valores "falsy" en JavaScript: false, 0, "", null, undefined, NaN
// Todos los demás valores son "truthy"

Operador de concatenación

En JavaScript, el operador + también se usa para unir cadenas de texto (strings).

let nombre = "María";
let apellido = "García";

// Concatenación básica
let nombreCompleto = nombre + " " + apellido;
console.log(nombreCompleto); // "María García"

// Concatenación con números
let edad = 30;
let presentacion = "Tengo " + edad + " años";
console.log(presentacion); // "Tengo 30 años"

// Template literals (alternativa moderna y recomendada)
let bio = `Hola, soy ${nombre} ${apellido} y tengo ${edad} años.`;
console.log(bio); // "Hola, soy María García y tengo 30 años."

Precedencia de operadores

Cuando hay múltiples operadores en una expresión, JavaScript los evalúa en un orden específico. Los operadores con mayor precedencia se evalúan primero.

// Sin paréntesis: la precedencia determina el orden
let resultado1 = 2 + 3 * 4;  // 2 + 12 = 14 (multiplicación primero)
let resultado2 = (2 + 3) * 4; // 5 * 4 = 20 (paréntesis primero)

console.log(resultado1); // 14
console.log(resultado2); // 20

// Tabla de precedencia (de mayor a menor):
// 1. () - Paréntesis
// 2. ** - Exponenciación
// 3. * / % - Multiplicación, División, Módulo
// 4. + - - Suma, Resta
// 5. < <= > >= - Comparación
// 6. == === != !== - Igualdad
// 7. && - AND lógico
// 8. || - OR lógico
// 9. = += -= *= /= %= - Asignación

"Siempre usa paréntesis para hacer explícito el orden de evaluación. Un código que depende de conocer la tabla de precedencia es propenso a errores y difícil de leer."

Expresiones en JavaScript

Una expresión es cualquier combinación de valores, variables, operadores y funciones que JavaScript puede evaluar para producir un resultado.

1. Expresiones aritméticas: Generan un número. Ejemplo: 10 + 5 * 2 → 20
2. Expresiones de cadena: Generan un string. Ejemplo: "Hola" + " " + "Mundo" → "Hola Mundo"
3. Expresiones lógicas: Generan true o false. Ejemplo: 5 > 3 && 2 < 4 → true
4. Expresiones de asignación: Asignan un valor y retornan ese valor. Ejemplo: x = 10 → 10

Ejercicios prácticos

// EJERCICIO 1: Calcula el área de un círculo
const PI = 3.14159;
let radio = 7;
let area = PI * radio ** 2;
console.log("Área del círculo:", area);

// EJERCICIO 2: Determina si alguien puede votar
let edadPersona = 16;
let esCiudadano = true;
let puedeVotar = edadPersona >= 18 && esCiudadano;
console.log("¿Puede votar?", puedeVotar);

// EJERCICIO 3: Calcula el precio final con descuento
let precioOriginal = 150;
let descuento = 20; // porcentaje
let precioFinal = precioOriginal - (precioOriginal * descuento / 100);
console.log("Precio final:", precioFinal);

// EJERCICIO 4: Verifica si un número es divisible por 3 y 5
let numero = 45;
let esDivisiblePor3y5 = numero % 3 === 0 && numero % 5 === 0;
console.log("¿Divisible por 3 y 5?", esDivisiblePor3y5);

Resumen

En esta lección hemos cubierto los operadores fundamentales de JavaScript:

• Aritméticos: + - * / % ** para cálculos matemáticos
• Asignación: = += -= *= /= %= para asignar y modificar valores
• Comparación: === !== > < >= <= para evaluar condiciones
• Lógicos: && || ! para combinar expresiones booleanas
• Concatenación: + para unir strings

Los operadores son la base sobre la cual construiremos lógica más compleja. Practica con cada tipo de operador hasta que te sientas cómodo, y siempre favorece la claridad sobre la brevedad.