Álgebra Booleana - Tutorial de Introducción a la Programación

Resumen Rápido

El álgebra booleana potencia las verificaciones lógicas en los programas. JavaScript usa evaluación de cortocircuito para && y ||, así que el motor puede dejar de evaluar una vez que el resultado es conocido. Esto habilita patrones como valores por defecto y cláusulas de guardia.

Fundamentos de Lógica Booleana

El álgebra booleana trabaja con valores verdadero/falso y tres operaciones principales:

AND (&&)

Ambos deben ser verdaderos:

true  && true  = true
true  && false = false
false && true  = false
false && false = false

OR (||)

Al menos uno debe ser verdadero:

true  || true  = true
true  || false = true
false || true  = true
false || false = false

NOT (!)

Invierte el valor:

!true  = false
!false = true

Tablas de Verdad

| A | B | A && B | A || B | !A | |---|---|--------|---------|-----| | V | V | V | V | F | | V | F | F | V | F | | F | V | F | V | V | | F | F | F | F | V |

Evaluación de Cortocircuito

JavaScript deja de evaluar tan pronto como el resultado es conocido:

// AND: stops at first false
false && expensiveFunction(); // Never calls function

// OR: stops at first true
true || expensiveFunction(); // Never calls function

Patrones Prácticos

Valores por defecto:

const name = userInput || "Guest";
// If userInput is falsy, use "Guest"

Cláusula de guardia:

user && user.name; // Only access if user exists
// Modern: user?.name (optional chaining)

Operador de coalescencia nula (??):

const count = input ?? 0;
// Only use 0 if input is null/undefined
// (unlike ||, doesn't treat 0 or "" as falsy)

Pruébalo Tú Mismo

Aquí tienes un ejemplo práctico que puedes probar. Copia este código y ejecútalo en la consola de tu navegador (presiona F12 para abrir las herramientas de desarrollo) o en el Playground de Código.

// Basic boolean operations
const a = true;
const b = false;

console.log(a && b);  // false (AND)
console.log(a || b);  // true (OR)
console.log(!a);      // false (NOT)
console.log(!b);      // true (NOT)

// Combining conditions
const age = 25;
const hasLicense = true;
const hasInsurance = true;

const canDrive = age >= 16 && hasLicense;
console.log("Can drive:", canDrive); // true

const canRentCar = age >= 21 && hasLicense && hasInsurance;
console.log("Can rent car:", canRentCar); // true

// Short-circuit evaluation
const user = null;
const username = user && user.name; // null (stops at user)
console.log(username);

// Default values with ||
const inputName = "";
const displayName = inputName || "Anonymous";
console.log(displayName); // "Anonymous"

// Nullish coalescing (??) - only null/undefined trigger default
const count = 0;
const displayCount = count ?? 10;  // 0 (not replaced)
const displayCount2 = count || 10; // 10 (0 is falsy)

// De Morgan's Laws
// !(A && B) === !A || !B
// !(A || B) === !A && !B
const x = true, y = false;
console.log(!(x && y) === (!x || !y)); // true
console.log(!(x || y) === (!x && !y)); // true

Puntos Clave

✓Combina valores verdadero/falso con AND, OR y NOT.
✓Practica con ejemplos de código reales para solidificar tu comprensión
✓Este concepto construye la base para temas más avanzados