¿Cómo usar operadores y expresiones en JavaScript?

Los operadores en JavaScript son símbolos que realizan acciones sobre valores: sumas, comparaciones, y decisiones lógicas.

Sin operadores, tu código no puede calcular precios, comparar datos ni tomar decisiones. Esta lección te muestra los tres grupos esenciales con ejemplos de nómina, IVA y descuentos.

Operadores aritméticos

Los operadores aritméticos realizan cálculos matemáticos. Son los más usados en cualquier sistema de ventas o nómina.

El operador % es útil para saber si un número es par o impar, o para pagos en quincenas.

Ejemplo 1 — Calcular el IVA de un producto en Liverpool

const precioBase = 1200;
const iva = precioBase * 0.16;
const precioFinal = precioBase + iva;

console.log("IVA:", iva);           // IVA: $192
console.log("Precio final:", precioFinal); // Precio final: $1,392

El IVA en México es el 16%. Multiplicas el precio base por 0.16 para obtenerlo.

Ejemplo 2 — Calcular descuento en Mercado Libre

const precioOriginal = 850;
const porcentajeDescuento = 0.20; // 20% de descuento
const descuento = precioOriginal * porcentajeDescuento;
const precioConDescuento = precioOriginal - descuento;

console.log("Descuento:", descuento);           // Descuento: $170
console.log("Precio final:", precioConDescuento); // Precio final: $680

Ejemplo 3 — Nómina quincenal en FEMSA

const salarioMensual = 18500;
const quincena = salarioMensual / 2;
const horasExtra = 3;
const pagoHoraExtra = 120;
const bonoBimestral = horasExtra * pagoHoraExtra;
const pagoTotal = quincena + bonoBimestral;

console.log("Quincena base:", quincena);   // Quincena base: $9,250
console.log("Bono horas extra:", bonoBimestral); // Bono horas extra: $360
console.log("Pago total:", pagoTotal);     // Pago total: $9,610

Operadores de asignación

Los operadores de asignación guardan o actualizan valores en una variable. Ya conoces =, pero hay versiones cortas muy útiles.

let saldo = 5000;
saldo += 1500; // Depósito
saldo -= 800;  // Retiro
console.log("Saldo actual:", saldo); // Saldo actual: $5,700

Operadores de comparación

Los operadores de comparación evalúan dos valores y devuelven true o false. Son la base de las decisiones en tu código.

Regla clave: Siempre usa === en lugar de ==. El === compara valor y tipo de dato, lo que evita errores difíciles de detectar.

Ejemplo — Validar si un empleado de Bimbo cumple con el mínimo de ventas

const metaVentas = 15000;
const ventasReales = 17200;

console.log(ventasReales >= metaVentas); // true
console.log(ventasReales === metaVentas); // false

Este resultado true o false es lo que usan los condicionales if para tomar decisiones. Lo verás en la siguiente lección.

Operadores lógicos

Los operadores lógicos combinan dos o más comparaciones para crear condiciones más complejas.

Ejemplo — Sistema de descuentos en Liverpool

const esSocio = true;
const compraMinima = 2000;
const totalCompra = 2500;

// El descuento aplica si es socio Y supera la compra mínima
const aplicaDescuento = esSocio && (totalCompra >= compraMinima);
console.log("¿Aplica descuento?", aplicaDescuento); // ¿Aplica descuento? true

// La promoción aplica si es socio O si su compra supera $3,000
const aplicaPromocion = esSocio || (totalCompra >= 3000);
console.log("¿Aplica promoción?", aplicaPromocion); // ¿Aplica promoción? true

// ¿No es socio?
console.log("¿No es socio?", !esSocio); // ¿No es socio? false

Orden de operaciones (precedencia)

JavaScript evalúa los operadores en un orden específico, igual que en matemáticas. La multiplicación y división van antes que la suma y resta.

// Sin paréntesis — JavaScript multiplica primero
const resultado1 = 100 + 50 * 2;
console.log(resultado1); // 200, no 300

// Con paréntesis — tú controlas el orden
const resultado2 = (100 + 50) * 2;
console.log(resultado2); // 300

Usa paréntesis siempre que el orden de operaciones afecte tu resultado. Es más claro y evita errores.

Errores comunes

Error 1 — Confundir = con ===

// MAL: esto asigna el valor 10 a x, no compara
let x = 5;
if (x = 10) { // Este código siempre es verdadero
  console.log("Siempre entra aquí");
}

// BIEN: esto compara correctamente
if (x === 10) {
  console.log("Solo entra si x es exactamente 10");
}

Error 2 — Usar == en lugar de === con tipos mixtos

const codigoUsuario = "5";
const codigoSistema = 5;

console.log(codigoUsuario == codigoSistema);  // true  ← peligroso
console.log(codigoUsuario === codigoSistema); // false ← correcto

El == convierte tipos automáticamente. Esto causa bugs difíciles de rastrear en sistemas reales.

Error 3 — Sumar números con strings

const precio = "500"; // String, no número
const iva = 80;

console.log(precio + iva); // "50080" ← concatena, no suma

Si un dato viene de un formulario, conviértelo primero con Number(precio) antes de operar matemáticamente.

Error 4 — No usar paréntesis en expresiones mixtas

// Intención: calcular el 16% de IVA sobre precio con descuento
const base = 1000;
const descuento = 100;
const ivaIncorrecto = base - descuento * 0.16; // Calcula: 1000 - (100 * 0.16) = 984
const ivaCorreecto = (base - descuento) * 0.16; // Calcula: (900) * 0.16 = $144

Siempre agrupa tus cálculos con paréntesis para asegurarte del orden correcto.

Resumen de operadores

Puntos clave

• Usa === y !== siempre. Nunca == ni != en código serio.
• Los operadores de comparación y lógicos devuelven true o false, no números.
• Usa paréntesis para controlar el orden de tus cálculos.
• Verifica que tus variables sean números antes de operar. Un string "500" más un número da texto, no suma.
• Los operadores && y || combinan condiciones: && exige que todo sea verdadero, || solo necesita una condición verdadera.