1. Operadores lógicos
Operadores lógicos
Operadores lógicos
Mediante operadores lógicos es
posible evaluar un conjunto de Aquí tienes las tablas de verdad de los distintos operadores lógicos.
variables lógicas, es decir, aquellas
cuyos valores sean únicamente: El operador AND
VERDADERO o FALSO (1 ó NUL).
Variables $a=32; $b=0; $c=-7; $d=4.32; $f="23 Ptas"
El resultado de esa evaluación será $x=$a>$b;$y=$a>$c;$z=$a>$f;
siempre 1 ó NUL. Ejemplo de sintaxis
echo ($x AND $y AND $z);
$A AND $B Otra sintaxis echo ($a>$b AND $a>$c AND $a>$f);
Condición A Condición B Condición C A B C Resultado
El operador AND devuelve
$a>$b $a>$c $a>$f 1 1 1 1
VERDADERO (1) en el caso de que
todas las variables lógicas $a>$b $a>$c $a<$f 1 1
comparadas sean verdaderas, y $a>$b $a<$c $a>$f 1 1
FALSO (NUL) cuando alguna de
$a<$b $a>$c $a>$f 1 1
ellas sea falsa.
$a<$b $a<$c $a>$f 1
$A && $B
$a<$b $a>$c $a<$f 1
El operador && se comporta de $a>$b $a<$c $a<$f 1
forma idéntica al operador AND. $a<$b $a<$c $a<$f
La única diferencia entre ambos es
que operan con distinta
precedencia. El operador &&
Más abajo veremos el orden de Variables $a=32; $b=0; $c=-7; $d=4.32; $f="23 Ptas"
precedencia de los distintos Condición A Condición B Condición C A B C Resultado
operadores.
$a>$b $a>$c $a>$f 1 1 1 1
$A OR $B $a>$b $a>$c $a<$f 1 1
Para que el operador OR devuelva $a>$b $a<$c $a>$f 1 1
VERDADERO (1) es suficiente que $a<$b $a>$c $a>$f 1 1
una sola de las variables lógicas $a<$b $a<$c $a>$f 1
comparadas sea verdadera.
Únicamente devolverá FALSO $a<$b $a>$c $a<$f 1
(NUL) cuando todas ellas sean $a>$b $a<$c $a<$f 1
FALSAS.
$a<$b $a<$c $a<$f
$A || $B
El operador || se comporta de El operador OR
forma idéntica al operador OR. Variables $a=32; $b=0; $c=-7; $d=4.32; $f="23 Ptas"
Su única diferencia es el orden de Condición A Condición B Condición C A B C Resultado
precedencia con el que opera.
$a>$b $a>$c $a>$f 1 1 1 1
$A XOR $B $a>$b $a>$c $a<$f 1 1 1
El operador XOR devuelve $a>$b $a<$c $a>$f 1 1 1
VERDADERO (1) sólo en el caso de $a<$b $a>$c $a>$f 1 1 1
que sea cierta una sola de las
$a<$b $a<$c $a>$f 1 1
variables, y FALSO (NUL) cuando
ambas sean ciertas o ambas sean $a<$b $a>$c $a<$f 1 1
falsas. $a>$b $a<$c $a<$f 1 1
! $A $a<$b $a<$c $a<$f
Este operador NOT (negación)
devuelve VERDADERO (1) si la El operador ||
variable lógica $A es FALSA y Variables $a=32; $b=0; $c=-7; $d=4.32; $f="23 Ptas"
devuelve FALSO (NUL) si el valor
Condición A Condición B Condición C A B C Resultado
de esa variable $A es VERDADERO.
$a>$b $a>$c $a>$f 1 1 1 1
Sintaxis alternativa $a>$b $a>$c $a<$f 1 1 1
Tal como hemos descrito los $a>$b $a<$c $a>$f 1 1 1
distintos operadores lógicos sería $a<$b $a>$c $a>$f 1 1 1
necesario que $A y $B contuvieran
$a<$b $a<$c $a>$f 1 1
valores lógicos, y eso requeriría un
paso previo para asignarles valores $a<$b $a>$c $a<$f 1 1
de ese tipo. $a>$b $a<$c $a<$f 1 1
Habría que recurrir a procesos de $a<$b $a<$c $a<$f
este tipo:
$A = $x>$y; El operador XOR
$B= $x >=$z; Variables $a=32; $b=0; $c=-7; $d=4.32; $f="23 Ptas"
$A && $B;
Condición A Condición B A B Resultado
pero se obtendría el mismo $a>$b $a>$c 1 1
resultado escribiendo:
$a>$b $a<$c 1 1
$x>$y && $x >=$z; $a<$b $a>$c 1 1
$a<$b $a<$c
que, aparte de ser la forma
habitual de hacerlo, nos evita dos
líneas de instrucciones. Ejemplo de uso de los operadores lógicos
Aunque el propio ejemplo se auto
comenta, digamos que al utilizar <?
operadores lógicos se pueden # asignemos valores a cuatro variables
sustituir las variables lógicas por $a=3;
expresiones que den como $b=6;

2. resultado ese tipo de valores.
$c=9;
$d=17;
Orden de precedencia # utilicemos operadores de comparación
Cuando se usan los operadores # y recojamos sus resultados en nuevas variables
lógicos se plantean situaciones $x= $a<$b;
similares a lo que ocurre con las $y= $a<$b;
operaciones aritméticas. $z=$c>$b;
# apliquemos un operador lógico (por ejemplo &&)
Dado que permiten trabajar con # e imprimamos el resultado
secuencias de operaciones sería
posible, por ejemplo, una
print("Resultado FALSO si no sale nada: ".($y && $z)."<br>");
operación de este tipo:
# hagamos la misma comparación sin utilizar la variables $y y $z
$a<$b OR $c<$b && $a<3 # que deberá darnos el mismo resultado
print("<br>Resultado FALSO si no sale nada: ".($a<$b && $c>$b)."<br>");
Surgirían preguntas con estas: /* veamos ahora que ocurre al ampliar la estructura
– ¿qué comparación se haría ¿qué ocurriría si escribíeramos
primero OR ó &&? $a<$b OR $c>$b && $d<$a ?
– ¿se harían las comparaciones en
El operador && tiene preferencia ante OR,
el orden natural?
luego haria primero la comparación $c>$b && $d<$a
– ¿alguno de los operadores tiene
prioridad sobre el otro? 9 > 6 es cierto, 17 < 3 es falso, luego como &&
solo devuelve cierto cuando ambos sean ciertos
Igual que en las matemáticas, el resultado de esa opción es FALSO.
también aquí, hay un orden de Veamos que ocurre al comparar $a<$b OR falso (resultado anterior)
prioridad que es el siguiente: como 3 < 6 es cierto OR operará con cierto y falso
que dará como resultado CIERTO, ya que basta que se
NOT, &&, ||, AND, XOR y, por
cumpla una de las condiciones */
último, OR.
/* vamos a comprobarlo mediante este operador condicional
De esta forma la operación && se no conocemos aun su sintaxis pero adelántemosla un poco...
realizaría antes que ||, mientras si el el contenido del paréntesis que va detrás del if es cierto
que si pusiéramos AND en vez de imprimirá cierto y en caso contrario imprimirá falso
&& sería la operación || la que se Aqui debería imprimirnos cierto */
haría antes y, por lo tanto, los if($a<$b OR $c>$b && $d<$a) {
resultados podrían variar de un print "cierto<br>";
caso a otro. }else{
Aquí también es posible, de la print "falso<br>";
misma manera que en la }
aritmética, utilizar paréntesis para # Cambiemos la estructura anterior por $a<$b || $c>$b AND $d<$a
priorizar una operación frente a # ahora se operará primero || que como antes dará cierto
otra. # pero ese resultado operado mediante AND con falso dará FALSO
# AL CAMBIAR LOS OPERADORES POR SUS SIMILARES el resultado el DISTINTO
Es muy importante prestar
atención a la construcción correcta
if($a<$b || $c>$b AND $d<$a) {
de estas estructuras. Un descuido
en la atención a las prioridades
print "cierto<br>";
puede ser origen –lo es }else{
frecuentemente– de resultados print "falso<br>";
incoherentes que suelen ser }
detectados bajo una apariencia # un paréntesis nos devolverá a la situación anterior
aleatoria. # escribamos $a<$b || ($c>$b AND $d<$a)
# veremos que el resultado es CIERTO como ocurría en el primer caso
Ten muy en cuenta que al depurar
programas no siempre se ven
if($a<$b || ($c>$b AND $d<$a)) {
fácilmente este tipo de errores de
print "cierto<br>";
programación.
}else{
Puede que para determinados print "falso<br>";
valores los resultados sean los }
esperados y que, sin embargo, al ?>
utilizar otros distintos pueda
manifestarse la incoherencia.
ejemplo23.php
Si te ocurriera esto no pienses que
es el ordenador el que está
haciendo cosas raras, procura
revisar los paréntesis y los criterios Ejercicio nº 18
de prioridad de los distintos
operadores contenidos en la Define tres variables: langosta, angula y caviar; y asígnales valores numéricos.
estructura lógica. Luego, escribe una estructura lógica que devuelva cierto en el caso de que dos de ellas
superen los precios respectivos de: 50, 70 y 500, y falso en cualquier otro caso.
Compruébalo modificando los valores de las variables y viendo los resultados y guárdalo
como ejercicio18.php.
Anterior Indice Siguiente