Operadores AND, OR y *NOT

Editar en línea

Los operadores lógicos *AND y *OR especifican la relación entre operandos en una expresión lógica. El operador lógico *NOT se utiliza para negar variables lógicas o constantes.

*AND y *OR son los valores reservados utilizados para especificar la relación entre operandos en una expresión lógica. El símbolo ampersand (&) puede sustituir el valor reservado *AND y la barra vertical (|) puede sustituir *OR. Los valores reservados deben ir precedidos y seguidos de espacios en blanco. Los operandos de una expresión lógica constan de expresiones relacionales o variables lógicas o constantes separadas por operadores lógicos. El operador *AND indica que ambos operandos (en cada lado del operador) tienen que ser verdaderos para producir un resultado verdadero. El operador *OR indica que uno u otro de sus operandos debe ser verdadero para producir un resultado verdadero.

Nota: El uso del símbolo ampersand o de la barra vertical puede causar problemas porque los símbolos no están en el mismo punto de código para todas las páginas de códigos. Para evitarlo, utilice *AND y *OR en lugar de los símbolos.

Utilice operadores que no sean operadores lógicos en expresiones para indicar las acciones que deben realizarse en los operandos de la expresión o la relación entre los operandos. Existen tres tipos de operadores distintos de los operadores lógicos:

Aritmético (+,-, *,/)
Carácter (*CAT, | |, *BCAT, | >, *TCAT, | <)
Relacional (*EQ, =, *GT, >, *LT, <, *GE, > =, *LE, < =, *NE, ¬ =, *NG, ¬ >, *NL, ¬ <)

Los ejemplos siguientes son sobre expresiones lógicas:


((&C *LT 1) *AND (&TIME *GT 1430))
(&C *LT 1 *AND &TIME *GT 1430)
((&C < 1) & (&TIME>1430))
((&C< 1) & (&TIME>1430))

En cada uno de estos casos, la expresión lógica consta de tres partes: dos operandos y un operador (*AND o *OR, o sus símbolos). Es el tipo de operador (*AND o *OR) que caracteriza la expresión como lógica, no el tipo de operando. Los operandos de las expresiones lógicas pueden ser variables lógicas u otras expresiones, como las expresiones relacionales. (Las expresiones relacionales se caracterizan por >, <, o = símbolos o valores reservados correspondientes.) Por ejemplo, en el ejemplo siguiente, toda la expresión lógica se encierra entre paréntesis, y ambos operandos son expresiones relacionales, también se encierran por separado entre paréntesis:


((&C *LT 1) *AND (&TIME *GT 1430))

Como puede ver en el segundo ejemplo de expresiones lógicas, los operandos no tienen que estar entre paréntesis separados, pero se recomienda para mayor claridad. Los paréntesis no son necesarios porque *AND y *OR tienen prioridades diferentes. *AND siempre se considera antes de *OR. Para operadores de la misma prioridad, se pueden utilizar paréntesis para controlar el orden en el que se realizan las operaciones.

Una expresión relacional simple se puede escribir como condición en un mandato:


IF (&A=&B) THEN(DO)
              .
              .
              .
              ENDDO

Los operandos de esta expresión relacional también pueden ser constantes.

Si desea especificar más de una condición, puede utilizar una expresión lógica con expresiones relacionales como operandos:


IF ((&A=&B) *AND (&C=&D)) THEN(DO)
                             .
                             .
                             .
                             ENDDO

La serie de mandatos IF dependientes citados como ejemplo en Mandatos IF incorporados en un programa o procedimiento CL podría codificarse:


PGM
DCL &RESP *DEC 1
DCL &A *DEC 1
DCL &B *CHAR 2
IF ((&RESP=1) *AND (&A=5) *AND (&B=NO)) THEN(DO)
                                           .
                                           .
                                           .
                                           ENDDO
CHGVAR &A VALUE(8)
CALLPRC PROC(DAILY)
ENDPGM

Aquí los operadores lógicos se utilizan de nuevo entre expresiones relacionales.

Debido a que una expresión lógica también puede tener otras expresiones lógicas como operandos, es posible una lógica bastante compleja:


IF (((&A=&B) *OR (&A=&C)) *AND ((&C=1) *OR (&D='0'))) THEN(DO)

En este caso, & D se define como una variable lógica.

El resultado de la evaluación de cualquier expresión relacional o lógica es '1' o '0' (verdadero o falso). El mandato dependiente sólo se procesa si la expresión completa se evalúa como verdadera ('1'). El mandato siguiente se interpreta en estos términos:


IF   ((&A = &B) *AND (&C = &D)) THEN(DO)
 
     ((true'1') *AND (not true'0'))
          (not true '0')

Finalmente, la expresión se evalúa como no verdadera ('0') y, por lo tanto, no se procesa el DO. Para obtener una explicación de cómo se ha alcanzado esta evaluación, consulte las matrices más adelante en esta sección.

Este mismo proceso se utiliza para evaluar una expresión lógica utilizando variables lógicas, como en este ejemplo:


PGM
DCL &A *LGL
DCL &B *LGL
IF (&A *OR &B) THEN(CALL PGM(PGMA))
.
.
.
ENDPGM

Aquí la expresión condicional se evalúa para ver si el valor de & A o de & B es igual a '1' (true). Si cualquiera de los dos es true, toda la expresión es true y se llama a PGMA.

La evaluación final a la que se ha llegado para todos estos ejemplos de expresiones lógicas se basa en matrices estándar que comparan dos valores (a los que aquí se hace referencia como & A y & B) bajo un operador *OR o *AND.

Utilice la siguiente matriz cuando utilice *OR con variables lógicas o constantes:

Si & A es:: '0' '0' '1' '1'
y & B es:: '0' '1' '0' '1'
la expresión OR es:: '0' '1' '1' '1'

En resumen, para varios operadores OR con variables lógicas o constantes, la expresión es falsa ('0') si todos los valores son falsos. La expresión es true ('1') si algún valor es true.


PGM
DCL &A *LGL VALUE('0')
DCL &B *LGL VALUE('1')
DCL &C *LGL VALUE('1')
IF (&A *OR &B *OR &C) THEN(CALL PGMA)
.
.
.
ENDPGM

Aquí los valores no son todos falsos; por lo tanto, la expresión es true y se llama a PGMA.

Utilice la siguiente matriz al evaluar una expresión lógica con *AND con variables lógicas o constantes:

Si & A es:: '0' '0' '1' '1'
y & B es:: '0' '1' '0' '1'
la expresión ANDed es:: '0' '0' '0' '1'

Para varios operadores AND con variables lógicas o constantes, la expresión es false ('0') cuando cualquier valor es false, y true cuando todos son true.


PGM
DCL &A *LGL VALUE('0')
DCL &B *LGL VALUE('1')
DCL &C *LGL VALUE('1')
IF (&A *AND &B *AND &C) THEN(CALL PGMA)
.
.
.
ENDPGM

Aquí los valores no son todos verdaderos; por lo tanto, la expresión es falsa y no se llama a PGMA.

Estos operadores lógicos sólo se pueden utilizar dentro de una expresión cuando los operandos representan un valor lógico, como en los ejemplos anteriores. Es incorrecto intentar utilizar OR o AND para variables que no son lógicas. Por ejemplo:


PGM
DCL &A *CHAR 3
DCL &B *CHAR 3
DCL &C *CHAR 3
 
Incorrect:   IF (&A *OR &B *OR &C = YES) THEN...

La codificación correcta para esto sería:


IF ((&A=YES) *OR (&B=YES) *OR (&C=YES)) THEN...

En este caso, el ORing se produce entre expresiones relacionales.

El operador lógico *NOT (o ¬) se utiliza para negar variables lógicas o constantes. Los operadores *NOT deben evaluarse antes de que se evalúen los operadores *AND u *OR. Los valores que siguen a los operadores *NOT deben evaluarse antes de que se evalúe la relación lógica entre los operandos.


PGM
DCL &A *LGL '1'
DCL &B *LGL '0'
IF (&A *AND *NOT &B) THEN(CALL PGMA)

En este ejemplo, todos los valores son true; por lo tanto, la expresión es true y se llama a PGMA.


PGM
DCL &A *LGL
DCL &B *CHAR 3 VALUE('ABC')
DCL &C *CHAR 3 VALUE('XYZ')
CHGVAR &A VALUE(&B *EQ &C)
IF (&A) THEN(CALLPRC PROCA)

En este ejemplo, el valor es false, por lo tanto, no se llama a PROCA.

Operadores *AND, *OR y *NOT

Operadores AND, OR y *NOT