Operadores y decisiones

⏱ 40 minutos
📶 Nivel: principiante
🧩 Incluye ejercicio

💡 🎯 Al terminar esta lección podrás…

Elegir el operador correcto y preferir siempre ===.
Combinar condiciones con &&, || y !.
Tomar decisiones con if, ternario y switch.
Escribir funciones que decidan y devuelvan un resultado.

1.Operadores

Tipo	Operadores	Ejemplo
Aritméticos	`+ - * / % **`	`7 % 2` → `1`
Asignación	`= += -= *= /= ++ --`	`total += 5` (suma 5 a `total`)
Comparación	`=== !== > < >= <=`	`3 > 2` → `true`
Lógicos	`&&` (y) `\|\|` (o) `!` (no)	`edad > 18 && tieneId`
Nulo/indefinido	`??` (si es null o undefined)	`nombre ?? "invitado"`
Condicional	`condición ? a : b`	`edad >= 18 ? "adulto" : "menor"`

▶ Operadores

Código (edítalo y pulsa Ejecutar)

<script>
  let puntos = 10;
  puntos += 5;           // 15
  puntos *= 2;           // 30
  puntos++;              // 31
  console.log(puntos);

  console.log(7 % 2);              // resto: 1
  console.log(7 % 2 === 0);        // ¿es par? false
  console.log(10 > 3, 10 === 10, 10 !== 7);
</script>

Página (resultado)

Consola

2.Comparar valores: `===` y `==`

Comparar es la base de las decisiones. Hay dos formas de preguntar «¿son iguales?», y una es mucho mejor:

Operador	Nombre	Qué hace
`===`	Igualdad estricta	Compara el valor y el tipo. Úsala siempre
`==`	Igualdad laxa	Convierte tipos antes de comparar: resultados sorprendentes
`!==`	Desigualdad estricta	Lo contrario de `===`

▶ == frente a ===

Código (edítalo y pulsa Ejecutar)

<script>
  console.log(5 == "5");      // true   ← convierte el texto a número
  console.log(5 === "5");     // false  ← tipos distintos
  console.log(0 == false);    // true   (sorpresa)
  console.log(0 === false);   // false
  console.log(null == undefined);   // true
  console.log(null === undefined);  // false

  console.log("a" < "b");     // true: se comparan alfabéticamente
  console.log(10 < 9);        // false
  console.log("10" < "9");    // true  (¡como texto, "1" < "9"!)
</script>

Página (resultado)

Consola

⚠️ Importante · Regla de oro

Usa siempre === y !==. == y != hacen conversiones que producen resultados difíciles de predecir y son fuente habitual de errores.

3.Operadores lógicos y valores «verdaderos»

Operador	Se lee	Es verdadero cuando…
`a && b`	a y b	ambos son verdaderos
`a \|\| b`	a o b	al menos uno es verdadero
`!a`	no a	`a` es falso

`a`	`b`	`a && b`	`a \|\| b`
`true`	`true`	`true`	`true`
`true`	`false`	`false`	`true`
`false`	`true`	`false`	`true`
`false`	`false`	`false`	`false`

Verdadero y falso («truthy» y «falsy»)

En una condición, JavaScript trata algunos valores como falsos aunque no sean false. Los valores falsos son solo estos seis: false, 0, "", null, undefined y NaN. Todo lo demás es verdadero.

▶ Truthy y falsy

Código (edítalo y pulsa Ejecutar)

<script>
  const valores = [false, 0, "", null, undefined, NaN, "0", "hola", [], {}, 42];
  for (const v of valores) {
    console.log(JSON.stringify(v), "→", v ? "verdadero" : "falso");
  }

  // && y || devuelven uno de los valores, no solo true/false
  const nombre = "";
  console.log(nombre || "invitado");     // "invitado"
  console.log(nombre ?? "invitado");     // ""  (?? solo mira null/undefined)
</script>

Página (resultado)

Consola

📌 Nota · || frente a ??

a || b usa b si a es cualquier valor falso (incluido 0 o ""). a ?? b usa b solo si a es null o undefined. Para valores por defecto, ?? suele ser lo correcto.

4.Tomar decisiones: if, else if y else

La estructura básica

if (condicion) {
  // se ejecuta si la condición es verdadera
} else if (otraCondicion) {
  // se ejecuta si la primera falló y esta es verdadera
} else {
  // se ejecuta si ninguna fue verdadera
}

▶ Clasificar una nota

Código (edítalo y pulsa Ejecutar)

<script>
  const nota = 7.5;

  if (nota >= 9) {
    console.log("Sobresaliente");
  } else if (nota >= 7) {
    console.log("Notable");
  } else if (nota >= 5) {
    console.log("Aprobado");
  } else {
    console.log("Reprobado");
  }
</script>

Página (resultado)

Consola

Cambia el valor de nota y observa qué mensaje aparece. Se evalúan las condiciones de arriba abajo y se ejecuta solo la primera que sea verdadera; por eso el orden importa.

Combinar condiciones

Y, O y NO

const edad = 20, tieneEntrada = true, esVip = false;

if (edad >= 18 && tieneEntrada) { console.log("Puede pasar"); }
if (esVip || edad >= 65)        { console.log("Acceso preferente"); }
if (!tieneEntrada)              { console.log("Debe comprar entrada"); }

5.El operador ternario y el cortocircuito

Cuando solo necesitas elegir entre dos valores, el operador ternario es más breve que un if:

condición ? siEsVerdadera : siEsFalsa

const edad = 20;
const tipo = edad >= 18 ? "adulto" : "menor";
console.log(tipo);                       // "adulto"

console.log(`Tienes ${edad} años y eres ${edad >= 18 ? "mayor" : "menor"} de edad`);

💡 Consejo · Legibilidad primero

Usa el ternario para decisiones simples y de una línea. Si necesitas varias condiciones o varias líneas, un if es más claro. Evita anidar ternarios: son difíciles de leer.

6.switch: muchas opciones sobre un mismo valor

▶ Un menú con switch

Código (edítalo y pulsa Ejecutar)

<script>
  const dia = 3;
  let nombre;

  switch (dia) {
    case 1:  nombre = "lunes"; break;
    case 2:  nombre = "martes"; break;
    case 3:  nombre = "miércoles"; break;
    case 6:
    case 7:  nombre = "fin de semana"; break;     // varios casos, mismo resultado
    default: nombre = "día no válido";
  }
  console.log(nombre);
</script>

Página (resultado)

Consola

Compara con === el valor con cada case.
Cada case termina con break; sin él, la ejecución «cae» al siguiente caso.
default se ejecuta si ningún caso coincide.
Para pocas opciones, if / else if suele bastar; switch brilla con muchos valores concretos.

7.Decisiones dentro de funciones

Casi todas las decisiones viven dentro de funciones, que verás a fondo en la lección 5. Por ahora, lo básico: una función recibe valores, decide y devuelve un resultado con return.

▶ Tu primera función con decisión

Código (edítalo y pulsa Ejecutar)

<script>
  function esPar(numero) {
    return numero % 2 === 0;
  }

  function categoriaEdad(edad) {
    if (edad < 13) return "niñez";
    if (edad < 18) return "adolescencia";
    if (edad < 65) return "adultez";
    return "adultez mayor";
  }

  console.log(esPar(4), esPar(7));
  console.log(categoriaEdad(10), categoriaEdad(30), categoriaEdad(70));
</script>

Página (resultado)

Consola

📌 Nota · return termina la función

Cuando una función ejecuta return, sale inmediatamente. Por eso en categoriaEdad no hace falta else: si la edad es menor de 13 ya devolvió «niñez» y no sigue leyendo.

8.Errores frecuentes

Usar = en lugar de === en una condición: if (x = 5) asigna y siempre es verdadero.
Usar == y llevarse conversiones sorpresa.
Condiciones en el orden equivocado: nota >= 5 antes de nota >= 9 captura todo.
Olvidar break en un switch.
Comparar textos como si fueran números ("10" < "9" es true).
Usar || para valores por defecto y descartar un 0 válido: usa ??.
Anidar demasiados if: usa retornos tempranos (if (!valido) return;).
Olvidar las llaves en un if con varias instrucciones.

📒 Apuntes para llevar

Los operadores aritméticos, de asignación (+=, ++), de comparación y lógicos son la base de toda decisión.
Usa siempre === y !==, nunca ==.
&& = «y», || = «o», ! = «no». Los valores falsos son solo false, 0, "", null, undefined y NaN.
?? aplica un valor por defecto solo si el original es null o undefined.
if / else if / else evalúa de arriba abajo y ejecuta solo la primera rama verdadera: el orden importa.
El ternario cond ? a : b sirve para elegir entre dos valores en una línea.
switch compara un valor con varios casos; cada caso termina con break.
return devuelve un valor y termina la función al instante.

9.Glosario

Término	Significado
Operador	Símbolo que realiza una operación (`+`, `===`, `&&`).
Condición	Expresión que se evalúa como verdadera o falsa.
Booleano	Valor `true` o `false`.
Truthy / falsy	Valores que se comportan como verdadero o falso en una condición.
Igualdad estricta	`===`: compara valor y tipo.
Ternario	Operador `cond ? a : b` que elige entre dos valores.
Cortocircuito	Evaluar solo lo necesario en `&&` y `\|\|`.
`switch`	Estructura que compara un valor con varios casos.

🧠 Comprueba lo aprendido

Elige una respuesta en cada pregunta. Verás al instante si acertaste y por qué.

¿Qué muestra console.log(5 === "5")?

=== compara también el tipo: número y texto son distintos.

¿Cuál de estos valores es verdadero en una condición?

El texto "0" no está vacío, así que es verdadero. Los falsos son false, 0, "", null, undefined y NaN.

const n = 0; console.log(n || 10) muestra…

0 es falso, así que || devuelve 10. Con ?? se mostraría 0.

Una cadena if / else if evalúa nota >= 5 antes que nota >= 9. ¿Qué problema hay?

Olvidas break en un case de un switch. ¿Qué pasa?

Sin break, la ejecución «cae» al caso siguiente.

Tu progreso se guarda en este navegador y se refleja en el índice del curso.

💡 🚀 ¡Ahora te toca!

La práctica fija lo aprendido. Pasa al ejercicio de esta lección.

Ir al ejercicio

1.Operadores

2.Comparar valores: === y ==

3.Operadores lógicos y valores «verdaderos»

Verdadero y falso («truthy» y «falsy»)

4.Tomar decisiones: if, else if y else

Combinar condiciones

5.El operador ternario y el cortocircuito

6.switch: muchas opciones sobre un mismo valor

7.Decisiones dentro de funciones

8.Errores frecuentes

📒 Apuntes para llevar

9.Glosario

🧠 Comprueba lo aprendido

2.Comparar valores: `===` y `==`