Fundamentos de JavaScript

Teoría: Lógica 🧠

Hasta ahora escribiste programas que muestran mensajes, hacen cuentas y repiten tareas. Ahora damos un paso gigante: enseñar al programa a tomar decisiones.

Este es el comienzo del bloque de lógica en JavaScript.
Aquí vas a aprender cómo hacer que tu programa diga cosas como:

  • “Si el usuario tiene menos de 18, no puede entrar.”
  • “Si el total es mayor a $10000, se aplica descuento.”
  • “Si el campo está vacío, muestro un mensaje de error.”

Este tipo de lógica está en casi todas las apps del mundo real.


¿Qué es una comparación?

Una comparación es una pregunta que puedes hacerle al código, como:

❓ ¿5 es mayor que 4?

❓ ¿"sol" es igual a "luna"?

Y la respuesta siempre será una de estas dos:

true   // sí
false  // no

Así de simple. Es como un interruptor: encendido (true) o apagado (false).

Estas respuestas se llaman valores booleanos. Es un tipo de dato que verás mucho a partir de ahora.

Veamos unos ejemplos

console.log(5 > 4); // true — porque sí, 5 es mayor que 4
console.log(3 === 3); // true — son iguales
console.log("sol" === "luna"); // false — no son iguales

Piensa que estás haciendo preguntas simples y JavaScript responde “sí” o “no”.

Operadores de comparación en JavaScript

JavaScript hereda los operadores matemáticos que ya conocemos, con una excepción: la igualdad.

Símbolo¿Qué pregunta hace?Ejemplo
<¿Es menor que...?3 < 5true
<=¿Es menor o igual que...?5 <= 5true
>¿Es mayor que...?8 > 2true
>=¿Es mayor o igual que...?3 >= 5false
===¿Son exactamente iguales? (valor y tipo)"hola" === "hola"true
==¿Son iguales? (convierte tipos si es necesario)5 == "5"true
!==¿Son distintos?7 !== 9true

🚨 Cuidado con =, == y ===

Es importante no confundirlos.

= (asignar)

Guarda un valor en una variable:

let edad = 18;

=== (comparar exacto)

Compara si son iguales y del mismo tipo:

18 === 18; // true 18 === "18"; // false

== (comparar con conversión)

Compara si son iguales, aun siendo de distinto tipo:

18 == "18"; // true

💡 Mejor usar === para evitar errores raros.

Ejemplo: saber si alguien es un bebé

Imaginemos que queremos escribir una función que determine si un bebé tiene menos de un año:

const esBebe = (edad) => edad < 1;

console.log(esBebe(0.5)); // true
console.log(esBebe(3));   // false

Esta función recibe una edad y contesta:

— ¿Tiene menos de un año?

Sí (true) o no (false). Nada más.

A las funciones que devuelven true o false se les llama predicados. Suelen empezar con is, has, can, etc.

Nombres típicos de predicados

Nombre en el código¿Qué pregunta responde?Versión en español
canVote()¿Puede votar?puedeVotar()
isEmpty()¿Está vacío?estaVacio()
isLoggedIn()¿Está conectado?estaConectado()
startsWithA()¿Empieza con A?empiezaConA()

Combinar operaciones lógicas

odd od even

Podemos combinar comparaciones y cálculos matemáticos. Un caso interesante es verificar si un número es par o impar. % es el operador para ver el resto de una división. Si no sobra nada (0), el número es par.

const esPar = (numero) => {
  return numero % 2 === 0;
};

console.log(10 % 2); // 0 → true Es par
console.log(9 % 2);  // 1 → false Es impar

Otro ejemplo: ¿la palabra empieza en mayúscula?

Queremos una función que nos diga si la primera letra de una palabra está en mayúscula. Para hacerlo:

  1. Tomamos la primera letra de la palabra.
  2. Comparamos si es igual a la versión en mayúscula de sí misma.
  3. Si son iguales → true, si no → false.
const empiezaEnMayuscula = (texto) => {
  const primera = texto[0];
  return primera === primera.toUpperCase();
};

console.log(empiezaEnMayuscula("Hola")); // true
console.log(empiezaEnMayuscula("mundo")); // false
console.log("Hola"[0]) // 'H'

Resumen

  • Las comparaciones en JavaScript devuelven valores booleanos (true o false).
  • Los operadores === y !== permiten comparar valores con precisión.
  • Las funciones que devuelven booleanos se llaman predicados.
  • Para verificar si un número es par, podemos usar number % 2 === 0.
  • Podemos usar comparaciones para preguntas más complejas, como verificar mayúsculas.

Las comparaciones son fundamentales en programación. ¡Practica con ellas y pronto podrás tomar mejores decisiones en tu código!