Gli operatori

Gli operatori sono un altro degli elementi base di qualsiasi linguaggio di programmazione, in quanto consentono non solo di effettuare le tradizionali operazioni aritmetiche, ma più in generale di manipolare il contenuto delle variabili.

Operatore di assegnazione - E' il più classico e conosciuto degli operatori e serve ad assegnare un valore iniziale ad una variabile:

$n = 'Filippo';

Il simbolo = serve, infatti, ad assegnare alla variabile $n il valore Filippo. In generale, si può dire che l'operatore di assegnazione inserisce nella variabile posta alla sua sinistra il valore posto alla sua destra. Il valore inserito può trovarsi anche, a sua volta, in un'altra variabile:

$a = 25;
$b = $a; 

Con la prima istruzione assegniamo a $a il valore 25, con la seconda assegniamo a $b lo stesso valore di $a, quindi alla fine il valore di $b sarà anch'esso 25.

Operatori aritmetici - Permettono di effettuare operazioni aritmetiche sui dati: addizione, sottrazione, divisione, moltiplicazione, modulo. Non hanno bisogno di molte spiegazioni, tranne chiarire che per modulo si intende il resto della divisione.

$a = 8 + 15;       // 23  addizione
$b = 80 - 52;      // 28  sottrazione
$c = 9 * 6;        // 54  moltiplicazione
$d = 68 / 2;       // 34  divisione
$e = 31 % 4;       //  3  modulo  

Operatore di concatenazione - Serve per unire più stringhe tra di loro. Il segno utilizzato per questo operatore è semplicemente il carattere '.' (punto).

$a = 'arco';
$b = 'baleno';
$t = $a . $b;      // $t vale 'arcobaleno' 

Operatori compatti - Con l'operatore di assegnazione si può usare una variabile per effettuare un calcolo il cui risultato deve essere assegnato alla variabile stessa. Ad esempio, supponiamo di avere una variabile di cui vogliamo aumentare il valore:

$a = $a + 20;      // il valore di $a aumenta di 20

Con questa operazione viene eseguito il calcolo dell'espressione che sta alla destra del segno = ed il risultato viene memorizzato nella variabile indicata a sinistra. Quindi, nel momento in cui viene effettuato il calcolo, al valore preesistente di $a viene sommato il valore 20 ed il risultato così ottenuto sostituirà il contenuto preesistente di $a.
Lo stesso risultato si può ottenere con l'espressione compatta:

$a += 20;          // il valore di $a aumenta di 20

A proposito delle espressioni compatte osserviamo che alcuni programmatori le preferiscono per rendere il loro codice più compatto, altri invece, specialmente per motivi didattici e di chiarezza, preferiscono evitarle.
Ecco un breve elenco di espressioni compatte usate nella programmazione PHP:

$x += 4;           // equivale a $x = $x + 4 
$x -= 3;           // equivale a $x = $x - 3
$x .= $a;          // equivale a $x = $x . $a (nel caso di stringhe)
$x /= 5;           // equivale a $x = $x / 5 
$x *= 4;           // equivale a $x = $x * 4
$x %= 2;           // equivale a $x = $x % 2  

In sostanza si chiede a PHP di assegnare alla variabile specificata a sinistra il risultato dell'operatore, che si trova prima del simbolo uguale, applicato alla variabile stessa ed al valore specificato a destra. Più facile a farsi che a dirsi.

Operatori di incremento e decremento - Sono molto usati nel caso sia necessario incrementare e decrementare una variabile di una sola unità:

$a++;         // incrementa di 1 $a dopo averla usata
++$a;         // incrementa di 1 $a e poi usala
$a--;         // decrementa di 1 $a dopo averla usata
--$a;         // decrementa di 1 $a e poi usala

Prestare la massima attenzione alla differenza tra anteporre e posporre l'operatore di incremento o decremento nel momento in cui si utilizzando questi operatori all'interno di espressioni. Anteporre l'operatore alla variabile dice al compilatore di incrementare la variabile e successivamente utilizzare il suo valore all'interno dell'espressione, mentre posporre l'operatore informa il compilatore che dovrà utilizzare nell'espressione il valore attuale e successivamente applicarvi l'incremento o il decremento.

Operatori di confronto - Questi operatori sono fondamentali perchè consentono di prendere delle decisioni in base all'esito del confronto fra due valori. Sono i responsabili dei differenti percorsi che uno script può prendere, eseguire determinate operazioni anzichè altre. Quando si utilizzano gli operatori di confronto, tra i due valori posti a sinistra e a destra dell'operatore stesso, il risultato sarà un valore booleano (true o false). Questi sono gli operatori:

==             // uguale
!=             // diverso
===            // identico (uguale per valore e tipo)
!==            // diverso (diverso o per valore o per tipo)
>              // maggiore
>=             // maggiore o uguale
<              // minore
<=             // minore o uguale

Ecco alcuni esempi, dopo aver assegnato il valore a tre variabili ne confrontiamo i valori:

$a = 27;  $b = 27.;  $c = 15;
$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 

Un'osservazione sul terzo confronto: poichè il valore assegnato a $b usando ha la notazione col punto decimale, per PHP $b è una variabile di tipo virgola mobile, anche se il suo valore è intero. Per questo motivo il confronto di identità restituisce falso.

Oltre che confronti fra valori numerici, si possono fare confronti anche con altri tipi di variabili, in particolare con le stringhe. In questo caso il confronto viene fatto carattere per carattere, basandosi sull'ordine alfabetico dei caratteri: vengono considerati minori i caratteri che vengono prima nell'ordine alfabetico. Quindi 'a' è minore di 'b', 'b' è minore di 'c', e così via. Inoltre tutte le lettere minuscole sono 'maggiori' delle lettere maiuscole, e tutte le lettere sia maiuscole sia minuscole, sono 'maggiori' delle cifre da 0 a 9. In sostanza l'ordine dipende dal codice ASCII di ciascun segno. Si verifichino le affermazioni seguenti in funzione di quanto appena detto.

$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 a tipizzazione debole permette di confrontare tra loro variabili contenenti tipi di dato differenti cercando di trasformare le variabili in valori confrontabili. Se per esempio si effettua un confronto == tra una variabile che contiene l'intero uno 1 ed una variabile che contiene la stringa uno '1' si ottiene un valore true dato che PHP trasforma entrambi i valori in numeri in modo che siano confrontabili. Per assegnare il valore numerico ad una stringa, PHP controlla se all'inizio della stringa ci siano dei numeri, se ne trova, considererà tutti i numeri consecutivi che trova come il valore numerico di quella stringa; se non ne trova, il valore della stringa sarà posto uguale a zero.

$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

Si faccia 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.

Nello sviluppo di un programma 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 si pensa contenga un numero contiene in realtà una stringa. È evidente che in questo caso si può facilmente ottenere un risultato diverso da quello aspettato. Oppure si può ottenere casualmente il risultato atteso, e in quest'ultima situazione è possibile che risultati inaspettati arrivino più avanti nello script utilizzando di nuovo la stessa variabile.

In tutte queste situazioni, conoscere come PHP tratta questi confronti può essere di aiuto per spiegare comportamenti apparentemente bizzarri dello 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.

Operatori logici - Vengono utilizzati per combinare più valori booleani, oppure per negarne uno (nel caso di NOT). Questi operatori sono:

or             // valuta se almeno uno dei due operatori è vero
||             // valuta se almeno uno dei due operatori è vero
and            // valuta se entrambi gli operatori sono veri
&&             // valuta se entrambi gli operatori sono veri
xor            // valuta se uno solo dei due operatori è vero (or esclusivo)
!              // inverte il valore logico (not)

Ecco qualche esempio:

10 > 8 and 7 < 6;      // falso (la prima condizione è vera, ma la seconda è falsa)
9 > 5 and 5 == 5;      // vero (entrambe le condizioni sono vere)
6 == 6 && 1 > 4;       // falso (solo la prima condizione è vera)
10 > 8 or 7 < 6;       // vero (la prima delle due condizioni è vera)
9 > 5 xor 5 == 5;      // falso (una sola delle due condizioni deve essere vera)
4 < 3 || 7 > 9;        // falso (nessuna delle due condizioni è vera)

Gli operatori and ed or hanno due diverse notazioni che differiscono per il livello di precedenza in caso di espressioni complesse. Poichè è possibile combinare molti operatori, in espressioni anche molto complicate, è necessario conoscere con quale ordine PHP valuta i diversi operatori. Queste regole partono dalle regole algebriche in base alle quali moltiplicazioni e divisioni hanno la precedenza su addizioni e sottrazioni, ma si complicano perchè devono considerare anche gli altri operatori. Ecco qual è l'ordine di priorità iniziando da quelli che hanno la precedenza:

Negli esempi sugli operatori logici, fatti in precedenza, sono state applicate le regole qui esposte, ed in particolare sono stati valutati prima gli operatori di confronto e, solo dopo, quelli logici.
Un'altra classica rappresentazione di esempio è quella dell'espressione algebrica:

 5 + 4  * 2;       // vale 13 perchè la moltiplicazione viene eseguita prima
(5 + 4) * 2;       // vale 18 perchè le parentesi modificano l'ordine di esecuzione

Come avviene in algebra, usando le parentesi si possono determinare quali operatori devono essere valutati per primi. Per questo motivo, sebbene sia possibile imparare a memoria l'ordine di precedenza mostrato in tabella, è meglio fare un uso accorto delle parentesi quando c'è bisogno di costruire un'espressione un po' complessa: in questo modo si riduce il rischio di errori, e soprattutto si rende il 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.