Booleanos y comparaciones

5 == "5" es true, pero 5 === "5" es false. El triple signo igual también comprueba que los dos lados sean del mismo tipo.

Preguntas con respuesta de sí o no

Los programas hacen preguntas todo el tiempo. ¿La contraseña es lo bastante larga? ¿Al jugador se le acabaron las vidas? ¿Hoy es fin de semana? Cada una tiene una de dos respuestas, y JavaScript las representa con los dos valores booleanos, true y false. Los booleanos se llaman así por George Boole, el matemático del siglo XIX que desarrolló un álgebra de lo verdadero y lo falso. Por sí solos no son muy emocionantes, pero son lo que permite que un programa tome decisiones, que es el tema de la unidad siguiente.

Operadores de comparación

Una comparación toma dos valores y produce un booleano. Abajo están los seis que más vas a usar. Fíjate en que "igual" se escribe con tres signos igual, porque un solo = ya significa "guardar un valor".

Como la aritmética, una comparación es una expresión, así que puedes imprimirla o guardarla en una variable: const isAdult = age >= 18; pone true o false en isAdult según la edad. Los nombres de variables booleanas suelen empezar con is, has o can, lo que hace que el código se lea como una pregunta.

Por qué === y no ==

JavaScript también tiene un doble igual, ==, llamado igualdad débil. Antes de comparar, intenta convertir los dos lados al mismo tipo, lo que produce resultados difíciles de predecir: 5 == "5" es true, y también 0 == "". El triple igual ===, igualdad estricta, nunca convierte. Si los tipos son distintos, la respuesta es simplemente false. MDN y la mayoría de las guías de estilo recomiendan === y !== para el código de todos los días, y este curso los usa siempre.

console.log(5 === 5);      // true
console.log(5 === "5");    // false
// igualdad débil, mejor evitarla:
console.log(5 == "5");     // true
console.log("cat" !== "dog"); // true

Las cadenas también se pueden comparar. === comprueba que dos cadenas tengan exactamente los mismos caracteres, mayúsculas incluidas, así que "Yes" === "yes" es false. Los operadores < y > comparan cadenas carácter por carácter usando sus códigos de carácter, lo que se parece al orden del diccionario para palabras en minúsculas: "apple" < "banana" es true. En ese orden, las mayúsculas van antes que todas las minúsculas, así que "Zebra" < "apple" también es true.

Combinar respuestas con &&, || y !

Las preguntas reales suelen tener varias partes. Un juego mecánico puede exigir una estatura de al menos 120 cm y una edad de al menos 8 años. JavaScript une respuestas booleanas con operadores lógicos. && (y) es true solo cuando los dos lados son true. || (o) es true cuando al menos un lado es true. ! (no) invierte un booleano, así que !true es false.

const height = 130;
const age = 7;
console.log(height >= 120 && age >= 8);   // muestra false
console.log(height >= 120 || age >= 8);   // muestra true
console.log(!(age >= 8));                 // muestra true

Ejemplo resuelto. ¿Un día es fin de semana? day === "Sat" || day === "Sun". Fíjate en que hay que repetir day === en los dos lados. Escribir day === "Sat" || "Sun" parece natural en inglés, pero no hace lo que quieres, porque "Sun" por sí solo no es una comparación. Las comparaciones se resuelven antes que && y ||, así que height >= 120 && age >= 8 no necesita paréntesis extra, aunque ponerlos nunca hace daño.

Una idea más que verás después: cuando JavaScript necesita un booleano pero recibe otro valor, trata unos cuantos valores como falsos. Estos valores falsy son false, 0, la cadena vacía "", null, undefined y NaN. Todo lo demás, incluidas las cadenas "0" y "false", cuenta como verdadero.