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.