Introducción a la programación

con JavaScript
Nahuel Roldán
roldannahuelj@gmail.com
Lógica booleana
Lógica booleana
La lógica booleana es un área de la lógica matemática que se centra en el
estudio de las operaciones lógicas y las expresiones booleanas. Recibe su
nombre en honor a George Boole, quien fue el primero en desarrollar un
sistema formal para el álgebra de la lógica.
La lógica booleana se basa en dos valores fundamentales: verdadero y falso.
Estos valores se pueden combinar utilizando operadores lógicos para
construir expresiones más complejas.
Proposiciones
En lógica, una proposición es una afirmación o enunciado que puede ser
evaluado como verdadero o falso.

Las proposiciones se representan generalmente mediante variables

proposicionales, las cuales pueden tomar los valores booleanos posibles:
verdadero (true) o falso (false).
Ejemplos
"El sol es una estrella."
Es un enunciado que podemos evaluar como verdadero, ya que el sol es, por definición,
una estrella.

"Todas las aves vuelan."

Es una proposición falsa, ya que hay aves que no vuelan (como el pingüino o el
ñandú).

"¡Ahora!"
Esta oración no es una proposición, ya que no puede ser considerada verdadera o
falsa.
Variables proposicionales
En lógica, las variables proposicionales son símbolos utilizados para representar
proposiciones o enunciados en forma de variables. Estas variables se utilizan para
expresar proposiciones de manera más general, sin asignarles un contenido
específico.

Como las mismas expresan proposiciones, cada variable proposicional puede tomar los
valores de verdadero o falso. Estos valores de verdad se asocian a la variable para
determinar el valor de verdad de la proposición que representa.

Las variables proposicionales permiten construir expresiones lógicas más complejas al

combinarlas mediante conectivas lógicas u operadores.
Podríamos declarar dos variables proposicionales p y q que representen los
siguientes enunciados:

p = "El usuario del programa es mayor de edad"

q = "El usuario del programa se llama Nahuel"

Por ahora podríamos evaluar estas propociones por separado según sea el
caso, pero también es posible vincularlas mediante conectores lógicos,
también conocidos como operadores lógicos.
Operadores lógicos
Los operadores lógicos son símbolos que se utilizan en la lógica para
combinar proposiciones y construir expresiones lógicas más complejas.
Estos conectores lógicos permiten establecer relaciones lógicas entre
proposiciones y determinar el valor de verdad de las expresiones
resultantes.

Los operadores lógicos básicos son:

NOT, AND, OR
1. NOT (NO): Es un operador unario que invierte el valor de una expresión
booleana. Si el valor original es verdadero, el resultado es falso, y
viceversa.
2. AND (Y): Es un operador binario que devuelve verdadero si y solo si ambos
operandos son verdaderos. De lo contrario, devuelve falso.
3. OR (O): Es un operador binario que devuelve verdadero si al menos uno
de los operandos es verdadero. Solo devuelve falso cuando ambos
operandos son falsos.
Para fines pedagógicos, representaremos estos operadores con los símbolos
de dichos operadores utilizados en JavaScript:

NOT ___________ !
AND ___________ &&
OR ___________ ||
Veamos la siguiente proposición:
"Mi nombre es Nahuel"

Podríamos representar a la misma por medio de una variable. Por ejemplo, r:

r = "Mi nombre es Nahuel"

En un primer momento no podríamos determinar el nivel de verdad de la

misma. Pero sabiendo que mi nombre es Nahuel, podemos decir que es true.
A partir de esta proposición podemos evaluar su inversa por medio del
operador de negación NOT, de modo que:

r = "Me llamo Nahuel"

!r = "No me llamo Nahuel"

Y como r es evaluada en true, sabemos que !r es false.

Si consideramos una segunda proposición:
"Tengo 28 años"

Y la representamos con la variable s:

s = "Tengo 28 años"

Nuevamente, adelantamos que la misma es true.

En base a ambas podemos crear una proposición compuesta por medio del
conector de conjunción:
"Mi nombre es Nahuel y tengo 28 años"

Podemos representarlo como:

r && s

Como ambas proposiciones son true, concluímos que true && true => true
Si definimos la variable t con una proposición false:
t = "Tengo 80 años"

Y creamos una nueva proposición por la conjunción con r:

r && t

Pero debido a que una de ellas es false:

true && false => false
Si tenemos la proposición compuesta:
"Me llamo Nahuel o tengo 80 años"

Que podemos expresar como:

r || t

Sabemos que para que la evaluación con el operador OR basta con que una
de las proposiciones sea true para que toda sea evaluada en true; por lo tanto:

r || t => true || false => true

Tabla de verdad
Una tabla de verdad es una herramienta utilizada en lógica para representar
el valor de verdad de una proposición o expresión en función de las
diferentes combinaciones de verdad de sus componentes o variables.

En una tabla de verdad, las columnas representan las variables o

componentes de la expresión, y las filas representan las diferentes
combinaciones posibles de verdad de esas variables. Cada celda en la tabla
muestra el valor de verdad correspondiente para la expresión en esa
combinación particular de variables.
La siguiente tabla de verdad muestra las combinaciones de los valores de:
p
q
!p (NOT p, no p)
!q (NOT q, no q)
p AND q (p y q)
p OR q (p o q)
Tabla de verdad
p q !p !q p && q p || q

T T F F T T

T F F T F T

F T T F F T

F F T T F F
Igualdad y desigualdad (estrictas)
Igualdad estricta (===): Es un operador binario que evalúa en verdadero si
ambos valores son iguales y son del mismo tipo. Caso contrario, se evaluará
en falso. Ejemplo:
1 === 1 // true
"1"=== 1 // false
Desigualdad estricta (!==): Es un operador binario que devuelve verdadero si
los valores comparados son distintos y del mismo tipo. Caso contrario, se
evaluará en falso. Ejemplo:
1 !== 1 // false
"1"!== 1 // true
Asignación vs. Igualdad
Un error común es confundir al operador de asignación con el operador de
igualdad. Recordemos: el operador de asignación se utiliza para asignar un
valor a una variable, mientras que el operador de igualdad se utiliza para
determinar si dos valores son equivalentes:

Asignación (=) Igualdad (===)

let nombre = "Juana" let nombre1 = "Juana"
nombre = "María" let nombre2 = "María"
console.log(nombre) console.log(nombre1 === nombre2)