Universidad del Valle de Guatemala

Campus Altiplano

Cátedra: Matemática Discreta

Catedrático: Ing. Luis López
Licenciatura en Tecnología de Sistemas Informáticos
Octavo Semestre

CONECTORES LÓGICOS

Camila Anna Sofía Estacuy Mazariegos

Carné 17745
12 de agosto de 2021

Índice
Conectores Lógicos.....................................................................................................................................3
Java..........................................................................................................................................................3
Operador and (&&).............................................................................................................................3
 Operador or (||)...................................................................................................................................3
Not (!)..................................................................................................................................................3
C++..........................................................................................................................................................4
AND lógico.........................................................................................................................................4
OR Lógico...........................................................................................................................................4
Negación Lógica..................................................................................................................................4
JavaScript................................................................................................................................................5
|| (OR)..................................................................................................................................................5
&& (AND)..........................................................................................................................................5
! (NOT)................................................................................................................................................5
PHP.........................................................................................................................................................5
Python.....................................................................................................................................................6
&& (AND)..........................................................................................................................................6
Operador or..........................................................................................................................................7
Operador not........................................................................................................................................7
Excel........................................................................................................................................................7
AND (Y)..............................................................................................................................................7
OR (O).................................................................................................................................................8
NO.......................................................................................................................................................8
MySQL....................................................................................................................................................8
AND....................................................................................................................................................8
OR.......................................................................................................................................................8
NOT.....................................................................................................................................................8
Anexos.........................................................................................................................................................9
Ejemplo Java...........................................................................................................................................9
Ejemplo C++...........................................................................................................................................9
Ejemplo JavaScript................................................................................................................................10
Ejemplo PHP.........................................................................................................................................11
Ejemplo Python.....................................................................................................................................11
Ejemplo Excel.......................................................................................................................................12
Ejemplo MySQL...................................................................................................................................12

2
 Conectores Lógicos
Java
Los operadores lógicos están relacionados con el álgebra de Boole. Evalúan una expresión en la que están
implicados uno o dos operandos con valor de tipo boolean. Retornan como resultando un valor lógico,
que será true si la evaluación de la expresión es cierta o false en caso contrario.
Existen tres operadores lógicos:

Operador and (&&)

Evalúa dos operandos de tipo lógico (pueden ser expresiones, variables o literales). Si ambos tienen valor
true el resultado de la evaluación será true. Con que uno de los dos (o los dos) sea false, el resultado
también lo será.
Este operando realiza evaluación de cortocircuito (o evaluación McCarthy). Esto significa que evaluará el
primer operando y, si este no tiene valor true no evaluará el segundo. Ya que los dos operandos deben ser
true para que la evaluación sea cierta, se puede ignorar el segundo cuando el primero sea false puesto que,
el resultado será false indistintamente del valor que tome el segundo operando.

Operador or (||)
Evalúa dos operandos de tipo lógico (pueden ser expresiones, variables o literales). Si al menos uno de los
dos tiene valor true el resultado de la evaluación será true. Para que el resultado sea false ambos tendrán
que serlo.
Este operador también realiza evaluación de cortocircuito. Si el primer operando tiene valor true no
evaluará el segundo. Ya que, con que uno tenga valor true es suficiente para que la evaluación sea cierta,
se puede ignorar el segundo si el primero es true. El resultado será true indistintamente del valor que tome
el segundo operando.

Not (!)
El operador de negación evalúa un solo operando con valor lógico y devuelve como resultado el valor de
este invertido. Es decir, si el operando tiene valor true este operador devolverá false y viceversa.

C++
AND lógico
La operatoria es como sigue: El primer operando (de la izquierda) es convertido a bool. Para ello, si es
una expresión, se evalúa para obtener el resultado. A continuación, el valor obtenido es convertido a bool

3
cierto/falso siguiendo las reglas de conversión estándar. Si el resultado es false, el proceso se detiene y
este es el resultado, sin que en este caso sea necesario evaluar la expresión de la derecha.
Si el resultado del operando izquierdo es cierto, se continúa con la evaluación de la expresión de la
derecha, que también es convertida a bool. Si el nuevo resultado es true, entonces el resultado del
operador es true. En caso contrario el resultado es false.

Operador Acción Ejemplo Resultado

&& AND lógico A && B Si ambos son verdaderos se
obtiene verdadero(true)

OR Lógico
Este operador binario devuelve true si alguno de los operandos es cierto. En caso contrario devuelve false.
Este operador sigue un funcionamiento análogo al anterior. El primer operando (izquierdo) es convertido
a bool. Para ello, si es una expresión, se evalúa para obtener el resultado. A continuación, el valor
obtenido es convertido a bool cierto/falso siguiendo las reglas de conversión estándar. Si el resultado es
true, el proceso se detiene y este es el resultado, sin que en este caso sea necesario evaluar la expresión de
la derecha.
Si el resultado del operando izquierdo es false, se continúa con la evaluación de la expresión de la
derecha, que también es convertida a bool. Si el nuevo resultado es true, entonces el resultado del
operador es true. En caso contrario el resultado es false

Operador Acción Ejemplo Resultado

|| OR Lógico A || B Verdadero si alguno es
verdadero
Negación Lógica
Este operador es denominado también No lógico y se representa en el texto escrito por la palabra inglesa
NOT (otros lenguajes utilizan directamente esta palabra para representar el operador en el código). El
operando (que puede ser una expresión que se evalúa a un resultado) es convertido a tipo bool, con lo que
solo puede ser uno de los valores cierto/falso. A continuación, el operador cambia su valor; Si es cierto es
convertido a falso y viceversa.
Resulta, por tanto, que el resultado de este operador es siempre un tipo bool, aunque al existir una
conversión estándar por la que un cero es convertido a false, y cualquier valor distinto de cero a true,
coloquialmente se dice que este operador convierte un operando 0 en 1 y uno no-cero en 0. En otras
palabras: este operador devuelve cierto (true) si la expresión se evalúa a distinto de cero, en caso contrario
devuelve falso (false).

Operador Acción Ejemplo Resultado

! Negación Lógica !A Negación de a

JavaScript
|| (OR)
En la programación clásica, el OR lógico está pensado para manipular solo valores booleanos. Si
cualquiera de sus argumentos es true, retorna true, de lo contrario retorna false.

4
En JavaScript, el operador es un poco más complicado y poderoso. Pero primero, veamos qué pasa con
los valores booleanos.
Hay cuatro combinaciones lógicas posibles:

La mayoría de las veces, OR || es usado en una declaración if para probar si alguna de las condiciones
dadas es true.

&& (AND)
En la programación clásica, AND retorna true si ambos operandos son valores verdaderos y false en
cualquier otro caso.

! (NOT)
El operador acepta un solo argumento y realiza lo siguiente:

1. Convierte el operando al tipo booleano: true/false.

2. Retorna el valor contrario.

PHP
Los operadores lógicos, nos permiten crear condiciones para las distintas estructuras en PHP, tanto en
estructuras condicionales como en estructuras repetitivas. Los operadores lógicos más importantes son
and (en español: y) y or (en español: o)

5
Una condición puede ser tan larga como se quiera o necesite y usar tantos operadores lógicos como se
quiera o necesiten. El uso de los paréntesis otorgará la prioridad de la ejecución de unas operaciones y
otras (como en matemáticas).
Las expresiones donde se utilizan operadores lógicos y relacionales devuelven un valor booleano, es
decir, verdadero (true) o falso (false). Por ejemplo si $a = 7 y $b = 5 la expresión $a < $b devuelve false
(es falsa). Si $a = true y $b = false la expresión $a && $b devuelve false (es falsa porque no se cumple
que $a y $b sean verdaderas). Si $a = true y $b = false la expresión $a || $b devuelve true porque uno de
los dos operandos es verdadero. Si $a = true la expresión !a devuelve false (el opuesto o contrario).
El operador || se obtiene en la mayoría de los teclados pulsando ALT GR + 1, es decir, la tecla ALT GR y
el número 1 simultáneamente.
Los operadores && y || se llaman operadores en cortocircuito porque si no se cumple la condición de un
término no se evalúa el resto de la operación. Por ejemplo: ($a == $b && $c != $d && $h >= $k) tiene
tres evaluaciones: la primera comprueba si la variable a es igual a b. Si no se cumple esta condición, el
resultado de la expresión es falso y no se evalúan las otras dos condiciones posteriores.
En un caso como ( $a < $b || $c != $d || $h <= $k) se evalúa si a es menor que b. Si se cumple esta
condición el resultado de la expresión es verdadero y no se evalúan las otras dos condiciones posteriores.

El operador ! recomendamos no usarlo hasta que se tenga una cierta destreza en programación. Una
expresión como (!$esVisible) devuelve false si ($esVisible == true), o true si ($esVisible == false). En
general existen expresiones equivalentes que permiten evitar el uso de este operador cuando se desea.

Python
&& (AND)
El operador and evalúa si el valor a la izquierda y el de la derecha son True, y en el caso de ser cierto,
devuelve True. Si uno de los dos valores es False, el resultado será False. Es realmente un operador muy
lógico e intuitivo que incluso usamos en la vida real. Si hace sol y es fin de semana, iré a la playa. Si
ambas condiciones se cumplen, es decir que la variable haceSol=True y la variable finDeSemana=True,
iré a la playa, o visto de otra forma irALaPlaya=(haceSol and finDeSemana).

6
Operador or
El operador or devuelve True cuando al menos uno de los elementos es igual a True. Es decir, evalúa si el
valor a la izquierda o el de la derecha son True.

Operador not
Y por último tenemos el operador not, que simplemente invierte True por False y False por True.
También puedes usar varios not juntos y simplemente se irán aplicando uno tras otro. La verdad que es
algo difícil de ver en la realidad, pero simplemente puedes contar el número de not y si es par el valor se
quedará igual. Si por lo contrario es impar, el valor se invertirá.

Dado que estamos tratando con booleanos, hemos considerado que usar True y False es lo mejor y más
claro, pero es totalmente válido emplear 1 y 0 respectivamente para representar ambos estados. Y por
supuesto los resultados no varían

Excel
AND (Y)
La Función Y en Excel sirve para examinar los valores lógicos recibidos por medio de los parámetros, si
todos los valores lógicos son Verdaderos, la función Y retornará VERDADERO, si al menos uno de los
valores es falso, la función Y devolverá FALSO.
Es decir, la Función Y sirve para exigir que todas las condiciones evaluadas se cumplan.
La Función Y puede recibir entre 1 y 255 parámetros, donde cada uno corresponde de un valor lógico o
condición lógica, es decir cada valor empleado puede ser VERDADERO o FALSO

7
OR (O)
La Función O en Excel nos permite evaluar los valores lógicos que se reciben en la función, si al menos
uno de los valores recibidos es VERDADERO, el resultado de la Función O será VERDADERO, por el
contrario, solo so todos los valores recibidos con FALSO, el resultado será FALSO.
Es decir, la Función O sirve para exigir que al menos una de las condiciones evaluadas se esté
cumpliendo.
La Función O permite evaluar entre 1 y 255 condiciones lógicas o parámetros, cada uno de estos valores
empleados puede corresponder al valor VERDADERO o FALSO.

NO
La Función NO en Excel permite cambiar un valor lógico, por el valor lógico opuesto, de esta forma si
tenemos en valor lógico VERDADERO, se cambiará por FALSO y si se tiene el FALSO, se cambiaría
por VERDADERO.
La función NO solo recibe un parámetro, el cual es obligatorio, y contener un valor lógico para que se
pueda realizar el cambio.

MySQL
AND
El operador AND muestra un registro cuando la primera condición y la segunda se cumplen.
Cuando usamos AND, es conveniente poner la condición con menor probabilidad de que se cumpla, en
primer lugar. El sistema de la base de datos evalúa las condiciones de izquierda a derecha. Si tenemos dos
o más operadores AND en una condición, el que está a la izquierda, es el primero en ser evaluado, y sólo
si es verdadera, se evalúa la siguiente condición. Si, esa condición también es verdadera, se evaluará la
tercera condición. Si ponemos la condición menos probable en primer lugar, se ahorra trabajo al sistema
de la base de datos, aumentando así la velocidad.

OR
El operador OR, muestra los registros cuando se cumple la primera condición O la segunda.

NOT
El operador "not" invierte el resultado de la condición a la cual antecede.
Los registros recuperados en una sentencia en la cual aparece el operador "not", no cumplen con la
condición a la cual afecta el "NO".
El orden de prioridad de los operadores lógicos es el siguiente: "not" se aplica antes que "and" y "and"
antes que "or", si no se especifica un orden de evaluación mediante el uso de paréntesis.
El orden en el que se evalúan los operadores con igual nivel de precedencia es indefinido, por ello se
recomienda usar los paréntesis.

8
 Anexos
Ejemplo Java

Ejemplo C++

9
Ejemplo JavaScript

10
11
Ejemplo PHP

Ejemplo Python

12
Ejemplo Excel

Ejemplo MySQL

13