GLI OPERATORI IN PHP SECONDA PARTE

GLI OPERATORI IN PHP

PRECEDENZA TRA GLI OPERATORI

La precedenza di un operatore specifica quanto “strettamente” lega insieme due espressioni. Ad esempio, nell’espressione 1 + 5 * 3, la risposta è 16 e non 18 perché l’operatore di moltiplicazione (“*”) ha una precedenza maggiore rispetto all’operatore di addizione (“+”). Le parentesi possono essere utilizzate per forzare la precedenza, se necessario. Ad esempio: (1 + 5) * 3 restituisce 18. Quando gli operatori hanno uguale precedenza, la loro associatività decide come raggruppare gli operatori. Ad esempio “-” è associativo a sinistra, quindi 1 – 2 – 3 è raggruppato come (1 – 2) – 3 e restituisce -4. “=” d’altra parte è associativo destro, quindi $a = $b = $c è raggruppato come $a = ($b = $c). Gli operatori di uguale precedenza che non sono associativi non possono essere utilizzati uno accanto all’altro, ad esempio 1 < 2 > 1 è illegale in PHP. L’espressione 1 <= 1 == 1 invece è legale, perché l’operatore == ha una precedenza inferiore rispetto all’operatore <=.

ASSOCIATIVITA’

L’associatività è significativa solo per gli operatori binari (e ternari). Gli operatori unari sono prefisso o suffisso, quindi questa nozione non è applicabile. Ad esempio !!$a può essere raggruppato solo come !(!$a). L’uso delle parentesi, anche quando non strettamente necessario, può spesso aumentare la leggibilità del codice rendendo esplicito il raggruppamento piuttosto che basarsi sulla precedenza e associatività dell’operatore implicito. La tabella seguente elenca gli operatori in ordine di precedenza, con quelli con la precedenza più alta in alto. Gli operatori sulla stessa riga hanno uguale precedenza, nel qual caso l’associatività decide il raggruppamento.

Copy to Clipboard

<?php
//PRECEDENZA TRA GLI OPERATORI
var_dump(true && false)."\n\r";
var_dump(true and false)."\n\r";
$test = true && false;//false
$test = true and false;/*--true. Abbiamo due operatori, l'assegnamento e l'operatore
logico and. L'operatore di assegnamento ha una precedenza maggiore rispetto all'operatore
and scritto in questo modo.(true) Se invece usiamo && questo ha una precedenza maggiore
rispetto all'assegnamento. (false). Se vogliamo che l'espressione sia sempre false
usiamo le parentesi.*/
$test = (true and false);
var_dump($test)."\n\r";
$sole = true;
$voglia = false;
if( ($sole === true ) && ( $voglia === true) ){  //Funziona tutto correttamente perchè && ha una precedenza
    //Passeggiata OK                     //inferiore rispetto a ===. Non è sbagliato usare le parentesi
                                         //in questo modo è più semplice capire che l'and logico &&
                                         //lega le due condizioni.
}
//SHORT-CIRCUIT EVALUATION
function fn1(){
    echo "Funzione ".__FUNCTION__ ." eseguita";
}
false && fn1();/*La funzione non viene invocata per il motivo seguente. PHP valuta la prima espressione
che inizia con un false, quindi in fn1() sia che ci sia true o false non cambia il risultato che sarà
sempre false.*/
true && fn1();/*La funzione viene invocata per il motivo seguente. PHP valuta la prima espressione
che inizia con un true, quindi PHP deve controllare fn1() perchè se sarà true
il risultato sarà true, se sarà false il risultato dell'espressione sarà false.
quindi in questo caso fn1() viene eseguita.*/
true || fn1(); //Non viene eseguita, la prima espressione è true, l'espressione sarà sempre true
// a prescindere da fn1(). Se la prima espressione determina già il risultato PHP non valuta
//la seconda espressione.

OPERATORI SU ARRAY CODICE

Copy to Clipboard

<?php
//OPERATORI SU ARRAY

$a = [1];
$b = ["1"];
var_dump($a == $b);//true il confronto tra i valori viene effettuato con l'uguaglianza semplice ==.
var_dump($a === $b);//false prima viene controllato il tipo. Non essendo uguali il risultato sarà false.
$a = ["valore 1" => 1];
$b = ["valore 2" => 1];
var_dump($a == $b);//false abbiamo chiavi diverse.
var_dump($a === $b);//false abbiamo chiavi diverse.
$a = ["valore 1" => 1];
$b = ["valore 1" => "1"];
var_dump($a == $b);//true confronta i valori a parità di chiave con l'uguaglianza semplice.
var_dump($a === $b);//false confronta i valori a parità di chiave con l'uguaglianza stretta.
$a = ["valore 1" => 1, "valore 2" => 2];
$b = ["valore 1" => 1, "valore 2" => 2];
var_dump($a == $b);//true confronta i valori a parità di chiave con l'uguaglianza semplice.
var_dump($a === $b);//true confronta i valori a parità di chiave con l'uguaglianza stretta.
$a = ["valore 2" => 2, "valore 1" => 1];
$b = ["valore 1" => 1, "valore 2" => 2];
var_dump($a == $b);//true.
var_dump($a === $b);//false deve corrispondere anche l'ordine.
$c = ["pizzaPreferita" => "margherita" , 28, 'JS',2];
$d = ["pizzaPreferita" => "capricciosa" , 30, "PHP"];
$e = $c + $d;
var_dump($e);
/*--Per quanto riguarda l'unione tra due array nel caso di elementi con la stessa chiave viene
preso l'array indicato sulla sinistra dell'operatore + */
$e = $d + $c;
var_dump($e);
/*--(Inversione degli array)Per quanto riguarda l'unione tra due array nel caso di elementi con la stessa chiave viene
preso l'array indicato sulla sinistra dell'operatore + */

OPERATORE TERNARIO CODICE

Copy to Clipboard

OPERATORE NULL COLESCING (PHP 7) CODICE

Copy to Clipboard

APPROFONDIMENTO

L’associatività in PHP si riferisce a come gli operatori vengono valutati in un’espressione che contiene più operatori dello stesso tipo. In particolare, determina la direzione con cui gli operatori sono associati e risolti quando ci sono operazioni multiple che devono essere valutate.

Tipi di Associatività

Ci sono due principali tipi di associatività in PHP:

1. Associatività da Sinistra a Destra (Left-to-Right Associativity):

• Gli operatori che seguono questa associatività vengono valutati partendo da sinistra verso destra. Ad esempio, gli operatori aritmetici come +, –, *, /, e % sono tutti associativi da sinistra a destra. Se hai un’espressione come 5 – 2 + 3, questa verrà valutata come (5 – 2) + 3.

<?php

$result = 5 – 2 + 3; // $result sarà uguale a 6
?>

2. Associatività da Destra a Sinistra (Right-to-Left Associativity):

•In questo caso, gli operatori vengono valutati partendo da destra verso sinistra. Un esempio comune di questo tipo di associatività sono gli operatori di assegnazione come = e gli operatori unari come ++ e —. Un’espressione come $a = $b = 5 viene valutata come $a = ($b = 5).

<?php

$a = $b = 5; // Prima viene valutato $b = 5, poi $a = $b
?>

Associatività degli Operatori Comuni in PHP

•Operatori Aritmetici (+, –, *, /, %): Associatività da sinistra a destra.

•Operatori di Assegnazione (=, +=, -=, *=, /=, %=): Associatività da destra a sinistra.

•Operatori di Confronto (==, !=, ===, !==, >, <, >=, <=): Associatività da sinistra a destra.

•Operatori Logici (&&, ||, and, or, xor): Alcuni hanno associatività da sinistra a destra (&&, ||), mentre altri (and, or, xor) dipendono dalla priorità rispetto ad altri operatori.

•Operatore di concatenazione (.): Associatività da sinistra a destra.

•Operatore ternario (? :): Associatività da destra a sinistra.

Esempio Dettagliato

Consideriamo un esempio pratico con vari operatori per vedere come l’associatività influisce sulla valutazione:

<?php

$result = 10 – 4 + 2 * 3;
// Associatività e precedenza:
// 1. Prima viene valutato 2 * 3 (precedenza più alta), risultato: 6
// 2. Poi 10 – 4 (associatività da sinistra a destra), risultato: 6
// 3. Infine, 6 + 6, risultato finale: 12

echo $result; // Output: 12
?>

Precedenza vs. Associatività

È importante non confondere la precedenza degli operatori con l’associatività. La precedenza determina quali operatori vengono valutati prima in un’espressione, mentre l’associatività determina l’ordine in cui gli operatori con la stessa precedenza vengono valutati.

Ad esempio, nell’espressione 2 + 3 * 4, l’operatore * ha una precedenza maggiore rispetto a +, quindi l’operazione 3 * 4 viene eseguita per prima, e solo dopo si esegue 2 + 12. L’associatività entra in gioco quando due operatori hanno la stessa precedenza, determinando l’ordine in cui vengono valutati.

Conclusione

Capire l’associatività è fondamentale per prevedere correttamente il risultato di espressioni complesse in PHP. Mantenere in mente come gli operatori vengono associati e valutati permette di scrivere codice più chiaro e privo di ambiguità, evitando potenziali errori logici che potrebbero derivare da una cattiva interpretazione delle espressioni.

LINK AI POST PRECEDENTI

IL LINGUAGGIO PHP

LINK AL CODICE SU GITHUB

GITHUB