Lezione10: Gli operatori logici e le espressioni booleane in PHP ~ Cerca Soluzione 3

Gli operatori di confronto

Gli operatori di confronto sono fondamentali perchè ci permettono, effettuando dei confronti fra valori, di prendere delle decisioni, cioè di far svolgere al nostro script determinate operazioni invece di altre. Quando utilizziamo gli operatori di confronto, confrontiamo i due valori posti a sinistra e a destra dell'operatore stesso.
Dopo aver valutato un'espressione questo tipo, PHP arriva a valutare se essa è vera o falsa. Quindi il risultato sarà di tipo booleano (true o false).

Operazioni di confronto
Operatore	Descrizione
`==`	uguale
`!=`	diverso
`===`	identico (cioè uguale e dello stesso tipo: ad esempio per due variabili di tipo intero)
`>`	maggiore
`>=`	maggiore o uguale
`<`	minore
`<=`	minore o uguale

Vediamo alcuni esempi:

$a = 7; $b = 7.0; $c = 4; //assegnamo valori a tre variabili
$a == $b;  // vero
$a == $c;  // falso
$a === $b; // falso, perchè $a è intero mentre $b è float
$a > $c;   // vero
$c >= $a;  // falso, $c è minore di $a
$a < $b;   // falso, hanno lo stesso valore
$c <= $b;  // vero

Una piccola osservazione sul terzo confronto: siccome abbiamo assegnato il valore di $b usando la notazione col punto decimale, per PHP $b è una variabile del tipo in virgola mobile, anche se in realtà il suo valore è intero. Per questo il confronto di identità restituisce falso.
Fino a qui abbiamo visto comunque casi molto semplici perchè tutte le variabili avevano valori numerici. Gli stessi confronti però si possono fare anche con altri tipi di variabili, ed in particolare con le stringhe. In questo caso il confronto viene fatto basandosi sull'ordine alfabetico dei caratteri: vale a dire che vengono considerati 'minori' i caratteri che 'vengono prima' nell'ordine alfabetico. Quindi 'a' è minore di 'b', 'b' è minore di 'c', eccetera. Inoltre tutte le lettere minuscole sono 'maggiori' delle lettere maiuscole, e tutte, maiuscole e minuscole, sono 'maggiori' delle cifre da 0 a 9:

$a = 'Mario'; $b = 'Giorgio'; $c = 'Giovanni'; $d = 'antonio'; $e = '4 gatti';

$a < $b; // falso, la 'G' precede la 'M'
$b < $c; // vero, la 'r' ('Gior') precede la 'v' ('Giov')
$d > $a; // vero, la 'a' minuscola è 'maggiore' di qualsiasi lettera maiuscola
$c > $e; // vero, ogni lettera è 'maggiore' di qualsiasi cifra

Dato che PHP è un linguaggio con una tipizzazione debole permette di confrontare tra loro variabili contenenti tipi di dato differenti cercando di trasformare le variabili in valori confrontabili. Se per esempio effettuassimo un confronto (==) tra una variabile contenente l'intero uno (1) ed una contenente la stringa uno ('1') otterremmo un valore di verità dato che PHP trasformerebbe entrambi i valori in numeri in modo che siano confrontabili. Per assegnare questo valore numerico, PHP controlla se all'inizio della stringa ci sono dei numeri: se ne trova, considererà tutti i numeri che trova inizialmente come il valore numerico di quella stringa. Se non ne trova, il valore della stringa sarà 0:

$a = 7; $b = 5; $c='molte persone'; $d='7 persone'; $e='5';

$a == $d;  // vero, $d vale 7
$a === $d; // falso, valgono entrambi 7 ma $a è un intero mentre $d è una stringa
$b > $c;   // vero, $b vale 5 mentre $c vale 0
$e > $c;   // falso: questo è un confronto fra due stringhe, quindi valgono le regole viste prima

Prestiamo attenzione all'ultimo esempio: il valore di $e era stato assegnato usando gli apici, e questo fa sì che PHP lo consideri una stringa anche se il contenuto è un numero.
Il confronto fra un numero e una stringa può avvenire in maniera voluta, ma è più probabile che avvenga per caso, quando cioè una variabile che pensavamo contenesse un numero contiene in realtà una stringa. È evidente che in questo caso potremo facilmente ottenere un risultato diverso da quello che ci aspettavamo, o, viceversa, potremmo ottenere casualmente il risultato atteso: in quest'ultima situazione è possibile che risultati inaspettati arrivino più avanti nello script, se utilizzeremo di nuovo la stessa variabile.
In tutte queste situazioni, tener presente il modo in cui PHP tratta questi confronti può essere di aiuto per spiegarci comportamenti apparentemente bizzarri del nostro script. È comunque buona norma assicurarsi che due espressioni restituiscano risultati dello stesso tipo quando si effettuano confronti, oppure utilizzare gli operatori === e !== che tengono conto anche del tipo di dato utilizzato.

Gli operatori logici

Con gli operatori logici possiamo combinare più valori booleani, oppure negarne uno (nel caso di NOT). Questi valori sono:

Operatore	Descrizione
`Or` o `\|\|`	valuta se almeno uno dei due operatori è vero; si può indicare con ' `Or` oppure col "doppio pipe" (`\|\|`)
`And` o `&&`	valuta se entrambi gli operatori sono veri; si indica con `And` o con la doppia "e commerciale" (`&&`)
`Xor`	viene chiamato anche 'or esclusivo', e valuta se uno solo dei due operatori è vero: l'altro deve essere falso; si indica con `Xor`
`!`	è l'operatore 'not' e vale come negazione. Si usa con un solo operatore: è vero quando l'operatore è falso, e viceversa; si indica con il punto esclamativo (`!`)

Anche in questa occasione vediamo qualche esempio:

10 > 8 And 7 < 6; // falso, perchè la prima condizione è vera ma la seconda è falsa
10 > 8 Or 7 < 6;  // vero
9 > 5 And 5 == 5; // vero, entrambe le condizioni sono vere
9 > 5 Xor 5 == 5; // falso, solo una delle due deve essere vera perchè si verifichi lo 'Xor'
4 < 3 || 7 > 9;   // falso, nessuna delle due condizioni è vera
6 == 6 && 1 > 4;  // falso, solo la prima condizione è vera

Per quanto riguarda gli operatori 'and' e 'or', le due diverse notazioni differiscono per il livello di precedenza in caso di espressioni complesse. Infatti, siccome è possibile combinare molti operatori in espressioni anche assai complicate, è necessario sapere con quale ordine PHP valuta i diversi operatori. Queste regole ricalcano le regole algebriche in base alle quali moltiplicazioni e divisioni hanno la precedenza su addizioni e sottrazioni, ma sono più complesse perchè devono considerare anche gli altri operatori. Vediamo quindi qual è l'ordine di priorità dei diversi operatori, iniziando da quelli che hanno la priorità maggiore:

Operatori di incremento e decremento (++ --)
Moltiplicazione, divisione, modulo (* / %)
Addizione e sottrazione (+ -)
Operatori di confronto per minore e maggiore (< <= => >)
Operatori di confronto per uguaglianza e disuguaglianza (== === !=)
Operatore logico 'and', nella notazione col simbolo (&&)
Operatore logico 'or', nella notazione col simbolo (||)
Operatori di assegnazione, compresi quelli 'sintetici' (= += -= /= *= %= .=)
Operatore logico 'and', nella notazione letterale (And)
Operatore logico 'xor' (Xor)
Operatore logico 'or', nella notazione letterale (Or)

Abbiamo già visto prima, in occasione degli esempi sugli operatori logici, l'applicazione di questi principi di precedenza: infatti in tutte quelle espressioni venivano valutati prima gli operatori di confronto e, solo dopo, quelli logici. Un'altra classica rappresentazione di esempio è quella dell'espressione algebrica:

5 + 4 * 2;   // questa espressione vale 13 e non 18,
             // perché la moltiplicazione viene eseguita prima

(5 + 4) * 2; // questa invece vale 18, perché le parentesi modificano 
             // l'ordine di esecuzione

Come abbiamo visto, così come avviene in algebra, usando le parentesi possiamo determinare a nostro piacere quali operatori devono essere valutati per primi. Per questo motivo, sebbene sia possibile imparare a memoria l'ordine di precedenza che abbiamo visto poco fa, il nostro consiglio è quello di non tenerne conto, e di utilizzare sempre le parentesi quando abbiamo bisogno di costruire un'espressione un po' complessa: in questo modo ridurremo il rischio di errori, e soprattutto renderemo il nostro codice molto più leggibile. Infatti leggere un'espressione regolata dalle parentesi è molto più immediato che non doversi ricordare quali degli operatori hanno la precedenza sugli altri.