Caratteristica comune a tutti i linguaggi di programmazione – e, dunque, propria anche di PHP – oltre alle variabili, è quella degli operatori.
Potremmo immaginare un operatore come una piccola scatola magica in cui inseriremo qualcosa – i nostri operandi – e ne tireremo fuori qualcosa di diverso rispetto a quello che abbiamo inserito – il nostro risultato -.
Gli operatori, quindi, eseguono un’operazione avendo a disposizione degli operandi.
Ne analizzeremo tre tipologie:
- operatori matematici
- operatori di confronto
- operatori logici
Operatori matematici in PHP
Gli operatori matematici agiscono su uno o più operandi e restituiscono un valore numerico.
Questi operatori, dunque, richiamano le operazioni matematiche che rappresentano:
- il + per l’addizione
- il – per la sottrazione
- il * per la moltiplicazione
- il / per la divisione
- il % per il modulo
- il ** per l’esponenziale.
Vediamoli all’opera su due operandi che, per noi, saranno:
$a=5 $b=2
Addizione (somma degli operandi)
Usando questo operatore matematico verra’ eseguita la somma tra i valori dati al momento dell’inizializzazione delle variabili (in questo caso 5 + 2 darà come risultato 7)
Sottrazione (Differenza fra gli operandi)
$a-$b significa che stiamo letteralmente attuando la sottrazione 5-2 e quindi il risultato sarà 3
Moltiplicazione (Prodotto fra operandi)
in maniera analoga, $a*$b ci restituirà come risultato il 10 (perchè 5*2=10)
Divisione (Quoziente fra operandi)
$a/$b significa che stiamo effettivamente dividendo 5 per 2 e ci restituirá un numero in virgola mobile che corrisponde al suo risultato, cioè 2.5 (ricordiamo che in php la virgola mobile sui numeri si indica con un punto).
Modulo (Resto degli operandi)
Quando parliamo di modulo ci riferiamo al resto degli operandi. Il resto è la quantità “avanzata” dopo aver effettuato la divisione, cioè quella quantità che non è stato possibile dividere affinché il risultato coincidesse con un numero intero. Con $a%$b vogliamo sapere quanto è avanzato dalla divisione di 5 con 2.
Il due “entra nel 5” per due volte, e lo scarto ottenuto è 1; il resto della divisione di 5 con 2 é, quindi, 1. E questo sarà esattamente il risultato del nostro modulo.
Esponenziale (a elevato alla potenza di b)
Quando vogliamo moltiplicare un numero tante volte per se stesso, è best practice non utilizzare l’operatore moltiplicazione, ma l’esponenziale.
Questo perché, ad esempio, 5*5*5*5*5 equivale a scrivere 5 elevato alla potenza di 5.
Tornando, quindi, ai nostri due operandi, con $a**$b stiamo elevando 5 alla potenza di 2 (potremmo, anche, dire “cinque alla seconda”). Questo equivale a scrivere 5×5, con risultato pari a 25.
Proviamo, ora, ad utilizzare i nostri operatori matematici in PHP.
<?php $x = 5; $y = 2; var_dump( $x + $y); var_dump( $x - $y); var_dump( $x * $y); var_dump( $x / $y); var_dump($x % $y); ?>
Il nostro output sará:
Nb. Abbiamo usato, nell’esempio, una funzione di php (var_dump) che ci consente di vedere in output anche il tipo di dato così da avere una visione piú chiara dei risultati.
Non preoccuparti, parleremo delle funzioni di php nel dettaglio nelle prossime guide, cosicché tu possa imparare php in maniera chiara e graduale.
Operatori di confronto in php
Gli operatori di confronto agiscono su due operandi e restituiscono un valore booleano (ovvero, un valore che può essere vero o falso: ricordi?).
Immaginiamo di avere come operandi un triangolo ed un cubo.
Facciamoci, ora, una serie di domande.
Il triangolo è uguale al cubo? Assolutamente falso!
Il triangolo è diverso dal cubo? Senza dubbio vero!
Il triangolo è piú grande del cubo? Se notiamo esserlo, la risposta sarà, ovviamente, vero.
Quelle che possono sembrare ovvietà, applicate al mondo della programmazione informatica, assumono una certa importanza.
Usciamo dalla metafora e proviamo a considerare due operandi $c e $d per analizzare nel dettaglio tutti i nostri operatori di confronto.
Uguale ( == )
$c == $d restituisce TRUE se $c é uguale a $d, FALSE in caso contrario
Identico ( === )
$c === $d restituisce TRUE se $c é uguale a $d, e sono anche dati dello stesso tipo, FALSE altrimenti
Estremamente importante è la differenza tra == e ===:
== fa un controllo se i due operandi sono uguali in valore.
=== fa un controllo se i due operandi sono uguali in valore ma anche in tipo di dato.
Saltiamo nuovamente nella nostra metafora! Non abbiamo più, però, a che fare con un cubo e un triangolo. Questa volta, i nostri operatori saranno due cubi: uno di pietra e uno di plastica.
Il primo operatore, quindi, restituirà TRUE poiché si tratta effettivamente di due cubi: il loro valore è uguale.
Il secondo operatore restituirà, invece, FALSE perché i due cubi sono composti da materiali diversi: uno è fatto di pietra, l’altro di plastica. Due tipologie diverse. Chiaro adesso?
Non identici ( !== )
$c !== $b restituisce TRUE se $c non é uguale in valore a $b, e non sono neppure dello stesso tipo, FALSE in caso contrario. Cominci a capire il meccanismo?
Non uguali ( != )
$c != $d restituisce TRUE se $c non é uguale a $d, FALSE altrimenti
Esiste anche un’altra sintassi per controllare se due operandi sono non uguali ed è $c <> $d
Minore di ( < )
$c < $d restituisce TRUE se $c é piú piccolo di $d, FALSE altrimenti
Maggiore di ( > )
$c > $d restituisce TRUE se $c é piú grande di $d, FALSE altrimenti
Minore o uguale ( <= )
$c <= $d restituisce TRUE se $c é piú piccolo o uguale a $d, FALSE altrimenti
Maggiore o uguale ( => )
$c >= $d restituisce TRUE se $c é piú grande o uguale a $d, FALSE altrimenti
Proviamoli in php:
<?php $c = 20; $d = 10; var_dump( $c == $d); var_dump( $c != $d); var_dump( $c <> $d); var_dump( $c < $d); var_dump( $c > $d); var_dump( $c <= $d); var_dump( $c >= $d); ?>
Il nostro output sará:
Facciamo, ora, degli altri esempi:
<?php $a = 10; $b = "10"; var_dump( $a == $b); //true perché in valore i due numeri sono uguali var_dump( $a === $b); //false perché i due numeri sono uguali in valore MA NON IN TIPO var_dump( $a != $b); //false perché in valore i due numeri sono uguali var_dump( $a !== $b); //true perché i due numeri sono uguali in valore MA NON IN TIPO ?>
Il nostro output sará:
Come puoi notare, nell’ultimo esempio le due variabili sono di tipo differente: una è un numero e una è una stringa.
Potremmo, tuttavia, applicare anche delle operazioni, poiché php riconosce una stringa numerica: analizza, cioè, partendo da sinistra, carattere per carattere e se riconosce un numero, lo userá come numero effettivo; se identifica, peró, immediatamente dopo, un carattere ci ritornerà un errore.
Vediamo direttamente degli esempi in php:
<?php $a = 10; $b = "10"; echo "PRIMO RISULTATO \n"; echo $a + $b; echo "\n"; $a = 10; $b = "10ciao"; echo "SECONDO RISULTATO \n"; echo $a + $b; echo "\n"; $a = 10; $b = "ciao10"; echo "TERZO RISULTATO \n" echo $a + $b; ?>
l’output sarà:
Osserviamo.
Il primo risultato è la normale somma;
nel secondo PHP ci mostra un avviso, ma in qualche modo riesce comunque a restituirci una somma.
Nel terzo, invece, abbiamo proprio un fatal error.
Operatori logici in PHP
Prima di definire che cosa sono gli operatori logici e vederli in azione, occorre precisare due concetti molto importanti.
Stiamo parlando dei concetti di dato truthy e dato falsy.
Dati truthi in PHP
Un dato è definibile truthy quando è quantificabile e contiene un valore non nullo.
Alcuni esempi possono essere:
Numeri diversi da zero;
Stringhe non vuote;
Array non vuoti (esempio: [3,’D’,2.3,”Ciao”]);
Il valore booleano True.
Dati falsy in PHP
Un dato è falsy, invece, quando contiene un valore nullo o non quantificabile. Ad esempio:
0;
Stringa vuota;
Array vuoto (esempio []);
Il valore booleano False.
Alcuni esempi in php:
<?php var_dump((bool) ""); // false var_dump((bool) " "); //true var_dump((bool) 1); //true var_dump((bool) -2); //true var_dump((bool) "foo"); //true var_dump((bool) 2.35); //true var_dump((bool) [12]); //true, var_dump((bool) []); // false var_dump((bool) "false"); //true ?>
Il nostro output:
Ciò detto, possiamo tornare ai nostri operatori logici.
Gli operatori logici agiscono su due operandi e restituiscono un valore booleano True o False e sono:
- AND la cui sintassi è la doppia “e commerciale” &&
- OR si indica con doppio “pipe”, chiamato anche “barra verticale” ||
- NOT si indica con il punto esclamativo !
L’operatore AND ritorna true SE E SOLO SE entrambi gli operandi sono valori truthy.
Esempio in php:
<?php var_dump(true && true); //true var_dump(true && false); //false var_dump(false && true); //false var_dump(false && false); //false ?>
Il nostro output:
L’operatore OR ritorna true SE ALMENO UNO degli operandi è un valore truthy.
Esempio in php:
<?php var_dump(true || false); //true var_dump(false || true); //true var_dump(true || true); //true var_dump(false || false); //false ?>
Il nostro output
L’operatore NOT ritorna il booleano inverso.
Per esempio, applicato a un valore truthy ritornerà false e viceversa.
Esempio in php:
<?php var_dump(!true); //false var_dump(!false); //true ?>
Il nostro output:
ATTENZIONE
Gli operatori && e || hanno una peculiaritá da non sottovalutare.
Consideriamo le regole appena viste, che prevedono che l’AND sia vero SE E SOLO SE entrambi gli operandi sono veri e l’OR sia vero se ALMENO UNO DEI DUE é vero.. Come avviene l’esecuzione della valutazione? Essa avverrà da sinistra verso destra.
Capiamo insieme come.
Supponiamo di avere i nostri due operatori che, questa volta, saranno due mele.
Chiediamoci: sono mele gialle? La risposta sará si se entrambe sono gialle.
Come farà il nostro operatore and a capirlo? Semplice: controllerà se la prima mela è gialla, e poi dovrà controllare se anche la seconda lo è.
Nel caso in cui la prima fosse, ad esempio, verde sarebbe inutile per lui controllare la seconda, che potrebbe a quel punto essere di qualsiasi altro colore: all’operatore non interesserà, poiché la risposta sarà già “le mele non sono entrambe gialle”. Il valore ritornato, dunque, sarà false.
Una delle due mele é gialla?
Se una delle due mele é effettivamente gialla, la risposta sará si. Ma sarà il nostro operatore or a capirlo. Come? Controllerà la prima mela, e, se questa sarà gialla l’operatore non avrà necessità di controllare la seconda: una delle due è del colore che cerca. Se, invece, la prima mela non dovesse essere gialla, l’operatore or dovrebbe, per forza di cose, andare a controllare la seconda. A quel punto la risposta sarà “true” se la seconda mela è del colore che l’operatore cerca, e “false” in caso contrario.
È chiaro, dunque, cosa succede quando utilizziamo l’and (&&) o l’or (||)?
Ribadiamolo: viene valutato il primo dato e, se è possibile capire se la risposta è vera o falsa sin dal primo controllo, il secondo dato non verrà considerato; se, peró, il controllo del primo dato non è sufficiente a darci una risposta, allora verrá valutato e considerato il secondo.
Alcuni esempi in php:
<?php
var_dump(5 && "pippo"); //TRUTHY && TRUTHY
var_dump(" " && 0); //TRUTHY && FALSY
var_dump(null && true); //FALSY && TRUTHY
var_dump([] && ""); //FALSY && FALSY
?>
- A riga 2 sono stati valutati entrambi i dati
- A riga 3 sono stati valutati entrambi i dati
- A riga 4 è stato valutato solo il primo
- A riga 5 è stato valutato solo il primo
Il nostro output
Qualche ulteriore esempio in php:
<?php
var_dump(5 || "pippo"); //TRUTHY && TRUTHY
var_dump(true || 0); //TRUTHY && FALSY
var_dump("" || [12]); //FALSY && TRUTHY
var_dump("" || 0); //FALSY && FALSY
?>
- A riga 2 è stato valutato solo il primo
- A riga 3 è stato valutato solo il primo
- A riga 4 sono stati valutati entrambi i dati
- A riga 5 sono stati valutati entrambi i dati
Il nostro output
