Il wiki della programmazione - Gli operatori in PHP

Home :: Pagine che puntano a questa :: Login/Register

Gli operatori in PHP

Assegnazione

In PHP, l'assegnazione avviene da destra a sinistra, ovvero il valore a destra è assegnato alla variabile a sinistra:
// Qui $a è null
$a = 1;
// Qui $a è 1
$b = $a;
// Qui sia $a sia $b valgono 1

L'operatore di assegnazione è =.
È possibile assegnare lo stesso valore a più variabili in un'unica operazione:
$a = $b = 1;
echo $a;
echo $b;

Il risultato sarà 11 (non undici, ma due singoli uno di seguito).
Inoltre, il risultato di un'operazione di assegnazione è il valore stesso:
  1. $a = ($b = 5) + 4; // ora $a vale 9 e $b vale 5

Confronto

L'operatore ==

NOTA: uno degli errori più comuni è quello di utilizzare = (singolo) come operatore di confronto; in C (e nei linguaggi derivati, come il php) un'istruzione come if($a = $b) è perfettamente legittima: si assegna il valore di $b ad $a, e se l'operazione va bene (cioè sempre) è restituito vero.

L'operatore di confronto è un doppio uguale ==.
$a = 1; $b = 2;
if($a == $b)
  echo "uguali";
else
  echo "diversi";

Questo script restituirà "diversi".
L'operatore = (assegnazione) ha la precedenza sull'operatore == (confronto):
  1. $a = 1; $b = 2;
  2. if($a == $b = 1)
  3.   echo "uguali";
  4. else
  5.   echo "diversi";

Questo script restituirà "uguali", in quanto alla riga 2 prima è eseguito $b = 1 e poi $a == $b.

L'operatore !=

L'operatore != verifica che due valori siano diversi:
NOTA: oltre a != è possibile utilizzare l'operatore <>

  1. $a = 1;
  2. $b = 2;
  3. if($a != $b)
  4.   echo "I valori sono diversi";

L'uso del ! per negare un valore booleano

Si può utilizzare il punto esclamativo da solo per negare un valore booleano o il casting corrispondente:
  1. $a = true;
  2. if(!$a)
  3.   echo "$a è falso";
  4. $b = 0;
  5. if(!$b)
  6.   echo "$b è falso";

In questo caso comparirà solo la scritta "$b è falso".

L'operatore ===

Tabella sull'uso di ===
  stesso tipo tipo diverso
stesso valore vero falso
valore diverso falso falso

Un altro operatore di confronto è ===. Questo operatore controlla che i due valori da confrontare siano uguali, e controlla che lo sia anche il tipo.
PHP infatti fa il casting automatico dei tipi, cioè - per esempio - se si aspetta un valore booleano (vero/falso) e il valore è numerico, effettua una conversione automatica e implicita:
  1. $a = 5;
  2. $b = 0;
  3. if($a == true)
  4.   echo "$a è vero!";
  5. if($b) // è come scrivere $b == true
  6.   echo "$b è vero!";

In questo esempio sia $a sia $b sono numerici, ma i rispettivi valori sono convertiti in vero/falso, in quanto if si aspettava un valore booleano.
In particolare, 0 (zero) è convertito in falso e non-0 è convertito in vero.
L'operatore === non permette questo:
  1. $a = true;
  2. $b = 0;
  3. $c = -1;
  4. if($a === true)
  5.   echo "$a è vero!";
  6. if($b === true)
  7.   echo "$b è vero!";
  8. if($c === true)
  9.   echo "$c è vero!";

In questo caso $a è vero, $b non sarebbe vero nemmeno con il casting implicito, mentre $c sarebbe vero se il confronto fosse fatto con ==, ma non lo è, dato che il confronto tramite === verifica che il dato presente in $c sia booleano.

L'operatore !==

L'operatore !== restituisce vero se O il tipo è diverso O il valore è diverso O entrambe le cose:
  1. $a = true;
  2. $b = 0;
  3. $c = -1;
  4. if($a !== true)
  5.   echo "$a non è vero!";
  6. if($b !== true)
  7.   echo "$b non è vero!";
  8. if($c !== true)
  9.   echo "$c non è vero!";

In questo caso $a è sia un booleano sia vero, di conseguenza non comparirà la scritta "$a non è vero!".
$b è numerico, e anche se ha un valore corrispondente a false comparirà lo stesso la scritta "$b non è vero!".
$c è numerico e inoltre non è booleano, quindi comparirà la scritta "$c non è vero!".

Gli operatori <, >, <=, >=

Nota bene: il contrario di maggiore non è minore, ma minore o uguale!

Gli operatori > (maggiore), < (minore), >= (maggiore o uguale), <= (minore o uguale) permettono di confrontare due numeri per determinare quale è il maggiore o il minore.
  1. $a = 1;
  2. $b = 5;
  3. if($a < $b)
  4.   echo "$a è più piccolo";

Nota: utilizzando anche gli operatori and e or, invertendo la direzione del confronto occorre anche cambiare and in or e viceversa.
  1. if($a < $b && $c < $d)
  2.   "caso 1";
  3. if($a >= $b || $c >= $d)
  4.   "caso 2";

Solo in questo modo si è sicuri di comprendere il 100% dei casi possibili.

Gli operatori aritmetici

+ - * / %

NOTA: L'operatore + può essere utilizzato anche per unire due matrici

Gli operatori sono + per la somma, - per la sottrazione, * per la moltiplicazione, / per la divisione e % per il resto della divisione.
Gli operatori +, -, *, / si applicano indifferentemente a numeri interi e con la virgola, mentre l'operatore di resto della divisione si applica solo a numeri interi.
Se si effettua una divisione tra numeri interi il risultato può essere un numero con la virgola (parsing automatico).
Esempi:
  1. $a = 1;
  2. $b = 2;
  3. echo $a + $b; // mostra 3

  1. $a = 1;
  2. $b = 0.5;
  3. echo $a + $b; // mostra 1.5, considerando anche $a un numero con virgola

  1. $a = 22;
  2. $b = 5;
  3. echo $a % $b; // mostra 2, dal momento che 22 / 5 dà 4 con il resto di 2

  1. $a = 22;
  2. $b = 3.8;
  3. echo $a % $b; // mostra 1, poiché tronca 3.8 in 3

  1. $a = 22;
  2. $b = 0;
  3. echo $a / $b; // restituisce un errore

Per una breve ma esauriente trattazione del problema della divisione per zero, consultare il sito di wikipedia alla voce divisione per zero∞

Gli operatori di incremento e decremento

Nei linguaggi derivati dal C, sono disponibili un operatore di incremento e uno di decremento, rispettivamente ++ e --.
L'operatore, posto prima o dopo la variabile, la incrementa o la decrementa:
  1. $a = 1;
  2. $a++;
  3. echo $a; // mostra 2

  1. $a = 1;
  2. $a--;
  3. echo $a; // mostra 0

Se un operatore di incremento è utilizzato in un'istruzione complessa, è importante valutare se l'operatore è prima o dopo la variabile.
Se è prima, l'incremento è calcolato prima dell'esecuzione dell'istruzione, altrimenti dopo:
  1. $a = 5;
  2. echo $a++; // mostra 5 e incrementa $a

  1. $a = 5;
  2. echo ++$a; // incrementa $a e mostra 6

Gli operatori aritmetici riferiti alla variabile stessa

Oltre all'operatore di incremento, è possibile utilizzare un segno aritmetico (+, -, *, /, %), uno di operazioni a bit (&, |; ~; >>; <) o il concatenamento di stringhe (.), seguito da un uguale (=) per effettuare un'operazione in cui il primo termine è la variabile stessa.
  1. $a = 7;
  2. $a += 5; // $a vale 12
  3. // equivale a $a = $a + 5;
  4. $a /= 3; // $a vale 4
  5. // equivale a $a = $a / 3;
  6. $a %= 3; // $a vale 1
  7. // equivale a $a = $a % 3;
  8. $a >>= 1; // $a vale 1, in quanto lo shift a destra equivale a una divisione per due con perdita del resto
  9. // equivale a $a = $a >> 1;
  10. $a .= " pinta"; // $a vale "1 pinta";
  11. // equivale a $a = $a . " pinta";

Operatori bitwise (bit a bit)

Un numero è memorizzato come sequenza di bit, in cui il primo vale 1, il secondo 2, il terzo 4 eccetera.
Per esempio, il numero 25.901 è memorizzato come 0110010100101101.
Se si mette il numero binario in una griglia in cui il valore più a destra è 1, il secondo 2 e così via, e poi si sommano i valori "1", si ottiene il valore decimale del numero:
Conversione di 25.901 da binario a decimale
32768 16384 8192 4096 2048 1024 512 256 128 64 32 16 8 4 2 1
0 1 1 0 0 1 0 1 0 0 1 0 1 1 0 1

1+4+8+32+256+1.024+8.192+16.384 = 25.901
Gli operatori bit-a-bit (detti bitwise) servono ad applicare operazioni binarie ai numeri.
Il motivo principale per cui si usano delle operazioni bitwise è di performance, e di solito sono usate su operazioni ripetitive e numerose.

L'operatore bitwise &

L'operatore & (AND) è utilizzato per confrontare i bit di due numeri: il risultato riporterà 1 solo sui singoli bit che sono 1 in entrambi i numeri:
  1. $a = 12345; // in codice binario a 16 bit è 0011000000111001
  2. $b = 54321; // in codice binario a 16 bit è 1101010000110001
  3. echo $a & $b; // il risultato è 0001000000110001 in decimale, cioè 4.145

L'operatore bitwise |

L'operatore | (OR) è utilizzato per confrontare i bit di due numeri: il risultato riporterà 1 sui singoli bit che sono 1 in almeno uno dei numeri:
  1. $a = 12345; // in codice binario a 16 bit è 0011000000111001
  2. $b = 54321; // in codice binario a 16 bit è 1101010000110001
  3. echo $a | $b; // il risultato è 1111010000111001 in decimale, cioè 62.521

L'operatore bitwise ^

L'operatore ^ (XOR) è utilizzato per confrontare i bit di due numeri: il risultato riporterà 1 sui singoli bit che sono 1 in almeno uno dei numeri, ma non in entrambi:
  1. $a = 12345; // in codice binario a 16 bit è 0011000000111001
  2. $b = 54321; // in codice binario a 16 bit è 1101010000110001
  3. echo $a ^ $b; // il risultato è 1110010000001000 in decimale, cioè 58.377

L'operatore XOR è molto usato in crittografia.

L'operatore bitwise ~

L'operatore ~ (NOT) è utilizzato per invertire i bit di due numeri: il risultato riporterà 1 sui singoli bit che sono 0 e viceversa:
  1. $a = 12345; // in codice binario a 16 bit è 0011000000111001
  2. echo ~$a; // il risultato è 1100111111000110 in decimale, cioè 53.190 (in realtà, dal momento che PHP non usa per default numeri a 16 bit, il risultato sarà -12.345

Gli operatori di shift

L'operatore >> sposta tutti i bit a destra di una posizione; viceversa l'operatore < li sposta a sinistra di una posizione.
Questo equivale rispettivamente a dividere (perdendo il resto) e moltiplicare per due:
  1. $a = 12345; // in codice binario a 16 bit è 0011000000111001
  2. $b = $a << 2; // si applica uno shift a sinistra di due posizioni, che è come moltiplicare per due due volte
  3. echo $b; // mostrerà 1100000011100100 in decimale, cioè 49.380, cioè 12.345 * 2 * 2

L'operatore di controllo degli errori @

L'operatore @ impedisce che sia visualizzato l'eventuale errore generato dalla funzione che segue.
Per esempio:
  1. $a = @(7/0); // non sarà visualizzato il messaggio di errore di divisione per zero

oppure:
  1. $risorsa = mysql_connect("server_non_esistente"); // non mostra il messaggio di server non raggiungibile

o anche:
  1. $oggetto = @new oggetto(); // se la creazione di un'istanza dell'oggetto fallisce non mostra errori

Operatore di esecuzione ``

Tutto quello che è racchiuso tramite `` (Non sono apostrofi, ma caratteri backticks) è eseguito come da una shell.
NOTA: la correttezza dell'esecuzione dipende dal sistema operativo su cui è eseguito il php!

Esempio:
  1. $file = `cat ciao.txt`;
  2. echo $file; // mostra lo stdout del comando cat ciao.txt

Questo operatore è abilitato solo se non è abilitata modalità sicura ed è disabilitata shell_exec().

Gli operatori logici

AND

L'operatore logico and (&&) restituisce vero solo se tutti i termini sono veri (cioè basta che uno solo dei suoi termini sia falso perché l'espressione sia falsa).
La tabella della verità con due termini è:
Condizione 1 Condizione 2 Risultato
V V V
V F F
F V F
F F F

Esempio:
  1. $cioccoBuona = true;
  2. $lavoroStanca = true;
  3. if($cioccoBuona && $lavoroStanca) {
  4.   echo "Hai le idee chiare!"; // sarà mostrato questo messaggio, perché entrambi i termini sono veri
  5. }
  6. $politicoOnesto = false;
  7. if($cioccoBuona && $politicoOnesto) {
  8.   echo "Credici!"; // non sarà mostrato questo messaggio, perché uno dei termini è falso
  9. }

OR

L'operatore logico or (||) restituisce vero se almeno uno dei termini è vero (cioè bisogna che tutti i suoi termini siano falsi perché l'espressione sia falsa).
La tabella della verità con due termini è:
Condizione 1 Condizione 2 Risultato
V V V
V F V
F V V
F F F

Esempio:
  1. $cioccoBuona = true;
  2. $politicoOnesto = false;
  3. if($cioccoBuona || $politicoOnesto) {
  4.   echo "Almeno una è vera!"; // sarà mostrato questo messaggio, perché uno dei termini è vero
  5. }
  6. $elefanteVola = false;
  7. if($elefanteVola || $politicoOnesto) {
  8.   echo "Credi anche a Babbo Natale?"; // non sarà mostrato questo messaggio, perché entrambi i termini sono falsi
  9. }

NOT

L'uso dell'operatore not (!) è stato trattato sopra

XOR

L'operatore logico xor restituisce vero se almeno uno dei termini è vero, ma non tutti.
La tabella della verità con due termini è:
Condizione 1 Condizione 2 Risultato
V V F
V F V
F V V
F F F

Esempio:
  1. $cioccoBuona = true;
  2. $politicoOnesto = false;
  3. if($cioccoBuona || $politicoOnesto) {
  4.   echo "Almeno una è vera!"; // sarà mostrato questo messaggio, perché uno dei termini è vero, ma non entrambi
  5. }
  6. $lavoroStanca = true;
  7. if($cioccoBuona && $lavoroStanca) {
  8.   echo "Magari!"; // non sarà mostrato questo messaggio, perché entrambi i termini hanno lo stesso valore (vero)
  9. }

L'operatore di concatenazione di stringhe

L'operatore di concatenazione di stringhe è .
Esempio:
  1. $a = "La pappa ";
  2. $b = "è buona";
  3. echo $a . $b; // mostrerà "La pappa è buona" (senza virgolette)

Operatori su matrici

+

L'operatore + unisce due matrici, preservando tutti i valori (ma eliminando le chiavi duplicate).
Esempio:
  1. $a = array("fusilli", "spaghetti", "stelline");
  2. $b = array("pomodori", "melanzane");
  3. echo "<pre>";
  4. var_dump($a + $b); // tutti i valori di $a e solo quelli di $b che non hanno chiavi in comune con $a
  5. var_dump($b + $a); // tutti i valori di $b e solo quelli di $a che non hanno chiavi in comune con $b
  6. echo "</pre>";

I risultati sono:
array(3) {
  [0]=>
  string(7) "fusilli"
  [1]=>
  string(9) "spaghetti"
  [2]=>
  string(8) "stelline"
}
array(3) {
  [0]=>
  string(8) "pomodori"
  [1]=>
  string(9) "melanzane"
  [2]=>
  string(8) "stelline"
}

=== e ==, !== e !=

== e != confrontano i valori presenti nei due array, === e !== confrontano i valori, le chiavi, l'ordine e i tipi presenti nei due array:
NOTA: oltre a != è possibile utilizzare l'operatore <>

  1. $a = array("5" => "Cinque", "6" => "Sei");
  2. $b = array(5 => "Cinque", 6 => "Sei");
  3. $c = array("6" => "Sei", "5" => "Cinque");
  4. if($a == $b) {
  5.   echo "gli array hanno gli stessi valori"; // questo messaggio sarà visualizzato
  6. }
  7. if($a == $c) {
  8.   echo "gli array hanno gli stessi valori"; // questo messaggio sarà visualizzato
  9. }
  10. if($a === $b) {
  11.   echo "gli array hanno gli stessi valori"; // questo messaggio NON sarà visualizzato in quanto i tipi delle chiavi sono diversi
  12. }
  13. if($a === $c) {
  14.   echo "gli array hanno gli stessi valori"; // questo messaggio NON sarà visualizzato in quanto l'ordine delle chiavi è diverso
  15. }

L'operatore ternario

L'operatore ternario è un operatore che permette di sintetizzare un'istruzione if...then...else.
La condizione è posta a sinistra di un ?, il valore se vero è posto tra ? e : e il valore se falso tra : e il ; finale.
Esempio:
  1. $a = 5;
  2. if($a < 10) {
  3.   echo $a . " è un numero piccolo";
  4. } else {
  5.   echo $a . " è un numero grande";
  6. }
  7. // può essere espresso tramite l'operatore ternario:
  8. echo $a < 10 ? $a . " è un numero piccolo" : $a . " è un numero grande";

Riferimenti
Il forum su PHP∞
Categories
PHP

Non ci sono commenti. [Aggiungere un commento]

Storico della pagina :: 2007-08-08 14:16:35 XML :: Proprietario: MarcoPagnin :: Cerca:

Valid XHTML 1.0 Strict∞ :: Valid CSS∞ :: Realizzato con Wikka Wakka Wiki 1.1.6.3∞
Page was generated in 0.4585 seconds