Operadores de comparación y operadores lógicos — JavaScript

¿Qué es y para qué sirve?

Imagina que eres un robot que ejecuta órdenes. Para tomar decisiones, necesitas poder comparar cosas y verificar condiciones. Por ejemplo:

• Comparación: "¿Tienes 100 rublos?" (comparas tu dinero con el número 100).
• Lógica: "¿Tienes 100 rublos Y no tienes hambre?" (verificas dos condiciones a la vez).

En JavaScript, los operadores de comparación y los operadores lógicos ayudan a la computadora a responder este tipo de preguntas. El resultado siempre será true (verdadero) o false (falso). Es como un semáforo: verde — puedes avanzar (true), rojo — te detienes (false).

¿Para qué sirve esto? Sin ellos, los programas serían aburridos — simplemente ejecutarían órdenes en secuencia. Pero con ellos, el programa puede reaccionar a diferentes situaciones: por ejemplo, si el usuario ingresó la contraseña correcta — dejarlo pasar, si no — mostrar un error.

En Python, estos operadores funcionan casi igual, pero en JavaScript tienen sus propias particularidades. Las analizaremos.

Ejemplos de código con explicación

1. Operadores de comparación básicos: >, <, >=, <=

Los más simples — como en la clase de matemáticas. Comparamos números:

// Ejemplo 1: ¿Mayor o menor?
let edad = 12;
let puedeEntrar = edad >= 12; // ¿Se puede entrar si la edad es 12 o más?
console.log(puedeEntrar); // Muestra: true (porque 12 >= 12 — es verdadero)

// Ejemplo 2: Comparación con un umbral
let temperatura = 30;
let haceCalor = temperatura > 25;   // ¿Mayor que 25?
console.log(haceCalor); // true (30 > 25 — es verdadero)

let haceFrio = temperatura < 10; // ¿Menor que 10?
console.log(haceFrio); // false (30 no es menor que 10)

// Ejemplo 3: ¡Las cadenas también se pueden comparar!
console.log("sandía" > "plátano"); // false
// ¿Por qué? Las letras se comparan alfabéticamente: 's' (letra 20) es mayor que 'p' (letra 17)
// En Python es igual, pero la sensibilidad a mayúsculas es diferente

Importante: En JavaScript, las cadenas se comparan según el código Unicode (como en una tabla). La "a" es menor que "z", y la "A" es menor que "a". Es como un diccionario: primero van las mayúsculas, luego las minúsculas.

2. Operadores de igualdad: == y ===

¡Aquí empieza lo interesante! En JavaScript hay dos formas de verificar si los valores son iguales:

• == — "igualdad no estricta" (compara valores, pero puede convertir tipos)
• === — "igualdad estricta" (compara tanto el valor como el tipo de dato)

// Ejemplo 4: Comparación de números y cadenas
let numero = 5;
let cadena = "5";

console.log(numero == cadena);   // true — porque 5 es igual a 5 (JavaScript convirtió la cadena a número)
console.log(numero === cadena);  // false — porque un número (number) no es igual a una cadena (string)!

// En Python esto no existe: "5" == 5 daría False inmediatamente, sin conversión

// Ejemplo 5: Comparación con true/false
console.log(1 == true);  // true — porque true se convierte a 1
console.log(1 === true); // false — tipos diferentes (número vs boolean)

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

// Ejemplo 6: Valores vacíos
console.log(null == undefined); // true — regla especial de JS
console.log(null === undefined); // false — tipos diferentes

// En Python no existe undefined, solo None, y no es igual a nada excepto a sí mismo

Consejo para principiantes: Usa siempre === (igualdad estricta) para evitar sorpresas. Es como en matemáticas: 5 y "5" son cosas diferentes, aunque se vean parecidas.

3. Operador lógico && (Y)

El operador "Y" (AND) devuelve true solo si ambas condiciones son verdaderas. En la vida real es como: "Saldré a pasear si hago la tarea Y mamá me lo permite".

// Ejemplo 7: Verificación de dos condiciones
let edad = 14;
let tieneBoleto = true;

let puedeIrAlCine = (edad >= 12) && (tieneBoleto === true);
console.log(puedeIrAlCine); // true — la edad es adecuada Y tiene boleto

// Si la edad fuera 10:
edad = 10;
puedeIrAlCine = (edad >= 12) && (tieneBoleto === true);
console.log(puedeIrAlCine); // false — la primera condición es falsa, la segunda es verdadera, pero Y requiere ambas

// Ejemplo 8: Condición compleja
let calificacion = 4;
let comportamiento = "excelente";

let recibiraElogios = (calificacion === 5) && (comportamiento === "excelente");
console.log(recibiraElogios); // false — la calificación no es 5, aunque el comportamiento sea excelente

// En Python se escribe igual: and

Truco: JavaScript es "perezoso" — si la primera condición en && es falsa, ni siquiera verifica la segunda. Esto se llama "cortocircuito". ¡Ahorramos tiempo!

4. Operador lógico || (O)

El operador "O" (OR) devuelve true si al menos una condición es verdadera. Como en la vida: "Saldré a pasear si hago la tarea O si hace sol afuera".

// Ejemplo 9: Elección entre dos opciones
let tieneDinero = false;
let tieneRegalo = true;

let puedeComprarJuguete = tieneDinero || tieneRegalo;
console.log(puedeComprarJuguete); // true — no tiene dinero, pero tiene un regalo (una condición es verdadera)

// Ejemplo 10: Verificación de edad
let edadUsuario = 17;
let entradaPermitida = (edadUsuario >= 18) || (edadUsuario >= 16 && tieneBoleto);
// Si la edad es >=18 O (la edad es >=16 Y tiene boleto)
console.log(entradaPermitida); // false — 17 no es >=18, y aunque 17>=16, tieneBoleto no está definido (undefined — es false)

// Ejemplo 11: Valores por defecto
let nombre = "";
let nombreMostrado = nombre || "Invitado";
console.log(nombreMostrado); // "Invitado" — porque la cadena vacía se considera false

// En Python: nombre or "Invitado" — funciona igual

Astucia: || también es "perezoso" — si la primera condición es verdadera, la segunda no se verifica. Esto se usa para establecer valores por defecto.

5.