13. Construcción de expresiones lógicas

Construir expresiones lógicas consiste en identificar proposiciones simples, elegir los operadores adecuados y agrupar las condiciones para representar una regla con precisión.

13.1 Introducción

Hasta ahora estudiamos proposiciones y operadores lógicos por separado. En la práctica, necesitamos combinarlos para representar reglas completas.

Una expresión lógica puede surgir de una frase en lenguaje natural, de una regla de negocio, de una validación de formulario o de una condición dentro de un algoritmo.

13.2 Qué es una expresión lógica

Una expresión lógica es una combinación de proposiciones, variables y operadores lógicos que produce un valor de verdad.

Si p, q y r son proposiciones, entonces expresiones como p ∧ q, ¬p ∨ r o (p ∧ q) → r también son expresiones lógicas.

En programación, una expresión lógica normalmente produce true o false.

13.3 Pasos para construir una expresión

Para construir una expresión lógica conviene seguir un proceso ordenado.

  1. Leer la regla completa.
  2. Identificar las proposiciones simples.
  3. Asignar nombres claros a cada proposición.
  4. Detectar conectores: no, y, o, si... entonces, si y solo si.
  5. Colocar paréntesis cuando haya grupos de condiciones.
  6. Revisar si la expresión representa exactamente la regla original.

13.4 Identificar proposiciones simples

Comencemos con esta regla:

El usuario puede publicar si está activo y tiene rol de editor.

Las proposiciones simples son:

  • p: El usuario está activo.
  • q: El usuario tiene rol de editor.

La expresión lógica es:

p ∧ q

13.5 Traducir a JavaScript

La misma regla puede escribirse en código usando variables booleanas.

const usuarioActivo = true;
const esEditor = true;

const puedePublicar = usuarioActivo && esEditor;

console.log(puedePublicar);

El operador && representa la conjunción lógica.

13.6 Expresiones con alternativas

Ahora consideremos una regla con alternativas:

El usuario puede acceder al panel si es administrador o supervisor.

Podemos definir:

  • p: El usuario es administrador.
  • q: El usuario es supervisor.

La expresión lógica es:

p ∨ q
const esAdmin = false;
const esSupervisor = true;

const puedeAccederPanel = esAdmin || esSupervisor;

console.log(puedeAccederPanel);

13.7 Expresiones con negación

La negación aparece cuando una regla exige que algo no ocurra.

El usuario puede ingresar si su cuenta no está bloqueada.

Si p significa "la cuenta está bloqueada", entonces la expresión es:

¬p
const cuentaBloqueada = false;

const puedeIngresar = !cuentaBloqueada;

console.log(puedeIngresar);

13.8 Agrupar condiciones

Cuando una regla mezcla varios operadores, los paréntesis indican cómo se agrupan las condiciones.

El usuario puede editar si es administrador o si es autor y el documento no está bloqueado.

Definimos:

  • p: El usuario es administrador.
  • q: El usuario es autor.
  • r: El documento está bloqueado.

La expresión es:

p ∨ (q ∧ ¬r)

13.9 Implementar una expresión agrupada

La expresión anterior puede implementarse así:

const esAdmin = false;
const esAutor = true;
const documentoBloqueado = false;

const puedeEditar = esAdmin || (esAutor && !documentoBloqueado);

console.log(puedeEditar);

Los paréntesis son importantes porque muestran que esAutor y !documentoBloqueado forman un grupo.

13.10 Expresiones con implicación

Algunas reglas se expresan mejor como implicaciones.

Si el usuario es menor de edad, entonces debe tener autorización.

Definimos:

  • p: El usuario es menor de edad.
  • q: El usuario tiene autorización.

La expresión lógica es:

p → q

Como p → q equivale a ¬p ∨ q, puede implementarse así:

const edad = 16;
const tieneAutorizacion = true;

const esMenor = edad < 18;
const reglaCumplida = !esMenor || tieneAutorizacion;

console.log(reglaCumplida);

13.11 Expresiones con bicondicional

Una regla con "si y solo si" exige que dos proposiciones coincidan.

El botón está habilitado si y solo si el formulario es válido.

La expresión lógica es:

p ↔ q
const formularioValido = true;
const botonHabilitado = true;

const reglaInterfazCorrecta = formularioValido === botonHabilitado;

console.log(reglaInterfazCorrecta);

13.12 Tabla de traducción rápida

Lenguaje natural Símbolo lógico JavaScript
No p ¬p !p
p y q p ∧ q p && q
p o q p ∨ q p || q
p o q, pero no ambas p ⊕ q p !== q
Si p, entonces q p → q !p || q
p si y solo si q p ↔ q p === q

13.13 Nombrar subexpresiones

Cuando una expresión es larga, es mejor dividirla en subexpresiones con nombres claros.

const edad = 24;
const emailVerificado = true;
const cuentaBloqueada = false;
const aceptoTerminos = true;

const esMayorDeEdad = edad >= 18;
const puedeUsarCuenta = emailVerificado && !cuentaBloqueada;
const registroCompleto = esMayorDeEdad && puedeUsarCuenta && aceptoTerminos;

console.log(registroCompleto);

Esta forma facilita revisar cada parte de la regla por separado.

13.14 Verificar con casos

Una expresión lógica debe probarse con casos representativos. Esto ayuda a detectar si la regla fue traducida correctamente.

Caso Datos Resultado esperado
Usuario válido Mayor de edad, email verificado, cuenta activa Permitir registro
Menor sin autorización Menor de edad, sin autorización Rechazar
Cuenta bloqueada Email verificado, pero cuenta bloqueada Rechazar ingreso

13.15 Errores comunes

  • No separar la regla en proposiciones simples antes de escribir la expresión.
  • Confundir "y" con "o" en reglas de negocio.
  • Olvidar paréntesis cuando se mezclan varios operadores.
  • Usar una implicación cuando solo se necesita una conjunción.
  • Escribir expresiones demasiado largas sin nombres intermedios.

13.16 Qué debes recordar de este tema

  • Una expresión lógica combina proposiciones y operadores.
  • Primero conviene identificar las proposiciones simples.
  • Los conectores del lenguaje natural deben traducirse con precisión.
  • Los paréntesis indican agrupación y evitan ambigüedad.
  • En programación, nombrar subexpresiones mejora la claridad del código.

13.17 Conclusión

Construir expresiones lógicas requiere pasar de reglas en lenguaje natural a proposiciones y operadores precisos. Esta habilidad es esencial para escribir condiciones correctas en programas.

En el próximo tema estudiaremos la precedencia de operadores lógicos.