Questo articolo è stato scritto per il "C", ma si può benissimo applicare a qalsivoglia linguaggio.
Tutti si trovavo prima o poi a verificare delle condizioni tramite gli Operatori Booleani
(& = AND, | = OR e ! = NOT)
Esaminiamoli:
OPERATORE NOT ( ! )
Serve a negare un espressione, cioè rappresenta l'opposto dell'espressione
Caso 1:
if( A==0) // Se A è uguale a 0
la negazione è
if ( !(A==0) ) // Se A NON è uguale a 0
oppure più semplicemente
if( A!=0 ) // se A è diverso da 0
Caso 2:
if( A>0 ) // SE A è STRETTAMENTE maggiore di 0
l'opposto è
if ( !(A>0) ) // Se A NON è STRETTAMENTE maggiore di 0
oppure più semplicemente
if( A<=0 ) // Se A è MINORE o UGUALE a 0
Caso 3:
if( A>=0 ) // Se A è MAGGIORE o UGUALE a 0
l'opposto è
if ( !(A>=0) ) //Se A NON è MAGGIORE o UGUALE a 0
oppure più semplicemente
if( A<0 ) //Se A è STRETTAMENTE MINORE di 0
(ATTENZIONE!! Se volete la condizioni STRETTAMENTE maggiore di 0 (A>0) la negazione comporterà pure l'uguale (A<=0), in caso contrario (A>=0) la negazione comporta solo lo STREATTAMENTE minore di 0 (A<0). )
AND e OR (& e |)
( A & B ) considera l'espressione come vera SE E SOLO SE TUTTE le varie parti sono VERE
( A | B ) considera l'espressione come vera PURCHE' SIA VERA ANCHE SOLO 1 delle sue parti.
A |
B |
& |
| |
||
F |
F |
F |
F |
||
F |
V |
F |
V |
||
V |
F |
F |
V |
||
V |
V |
V |
V |
||
In 'C' gli operatori sono rappresentati con && (AND) e || (OR)
Esempio, "Esegui un istruzione se A è un valore compreso tra 1 e 10"
if ( (A>=1) && (A<=10) ){
...
}
E se volessimo esattamente il contrario?
if ( !( (A >=1) && (A<=10) )){
...
}
Qui possono venirci in aiuto le LEGGI DI DE MORGAN
!( A && B ) = ( !(A) || !(B) )
!( A || B ) = ( !(A) && !(B) )
Ovvero:
- la negazione dell'AND di due variabili è uguale all'OR della negazione delle singole variabili (e viceversa)
- la negazione dell'OR di due variabili è uguale all'AND della negazione delle singole variabili (e viceversa)
Da cui (applicando la negazioni ad entrambi i membri, la quale non cambia l'equivalenza)
!( !( A || B ) ) =!( ( !(A) && !(B) ) )
!( !( A && B ) ) =!( ( !(A) || !(B) ) )
abbiamo,
A || B = !( !(A) && !(B) )
A && B = !( !(A) || !(B) )
Nel caso di molti membri
A && B && C … = ! (!(A) || !(B) || !(C) …)
A || B || C … = ! (!(A) && !(B) && !(C) …)
Nell'esempio di prima avremo:
if ( !( (A >=1) && (A<=10) )){
...
}
che sarà uguale a
if ( !(A >=1) || !(A<=10) ){
...
}
o più semplicemente
if ( (A <1) && (A>10) ){
...
}
Short-circuit
Nel Linguaggio C (ma anche in altri come il C++, C#, Python ecc..) c'è un meccanismo per cui in un espressione booleana del tipo
if ( A && B )
verrà dapprima valutata l'espressione A.
Se essa è VERA, si procederà alla valutazione dell'espressione B, se invece risulta essere FALSA, NON si procederà alla valutazione dell'espressione B in quanto qualunque sia il valore logico di B, tutta l'espressione sarà FALSA.
Similmente per l OR: Se la prima espressione risulta essere VERA, la verifica della seconda espressione risulterà superflua, quindi non verrà eseguita.
Aggiungi un commento