From 992efde4a2a1cbeb6fd6e6f7f63467ddffb8f41f Mon Sep 17 00:00:00 2001 From: Davide Pastore Date: Mon, 2 Feb 2026 14:25:24 +0000 Subject: [PATCH 1/4] Sync fgetcsv.xml --- reference/filesystem/functions/fgetcsv.xml | 25 ++++++++++++---------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/reference/filesystem/functions/fgetcsv.xml b/reference/filesystem/functions/fgetcsv.xml index accd11da4..0c8d018de 100644 --- a/reference/filesystem/functions/fgetcsv.xml +++ b/reference/filesystem/functions/fgetcsv.xml @@ -1,5 +1,5 @@ - + @@ -90,18 +90,21 @@ Deve essere un carattere a byte singolo o la stringa vuota. La stringa vuota ("") disabilita il meccanismo di escape proprietario. - + - Di solito, per effettuare l'escape di un carattere enclosure all'interno di - un campo lo si duplica; tuttavia, il carattere - escape può essere usato come alternativa. Pertanto, con i valori predefiniti del - parametro "" e \" hanno lo stesso - significato. Oltre a consentire di effettuare l'escape del - carattere enclosure, il - carattere escape non ha significato speciale; non è - nemmeno destinato ad effettuare l'escape di se stesso. + Nel flusso di input, il carattere enclosure + può sempre essere sottoposto a escape raddoppiandolo all’interno di una stringa tra virgolette, + producendo un singolo carattere enclosure + nel risultato analizzato. + Il carattere escape funziona in modo diverso: + se una sequenza di caratteri escape e + enclosure appare nell’input, + entrambi i caratteri saranno presenti nel risultato analizzato. + Quindi, per i parametri predefiniti, una riga CVS come + "a""b","c\"d" avrà i campi analizzati come + a"b e c\"d, rispettivamente. - + A partire da PHP 8.4.0, dipendere dal valore predefinito di From bc6b6b60386682180fb72795962684f8b0516f9d Mon Sep 17 00:00:00 2001 From: Davide Pastore Date: Mon, 2 Feb 2026 15:43:55 +0000 Subject: [PATCH 2/4] Sync with EN --- reference/curl/book.xml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/reference/curl/book.xml b/reference/curl/book.xml index 85d0b7773..111b77220 100644 --- a/reference/curl/book.xml +++ b/reference/curl/book.xml @@ -1,6 +1,6 @@ - - + + @@ -30,6 +30,7 @@ &reference.curl.curlhandle; &reference.curl.curlmultihandle; &reference.curl.curlsharehandle; + &reference.curl.curlsharepersistenthandle; &reference.curl.curlfile; &reference.curl.curlstringfile; From 44ee4ee911d5fa29d49eb587498e930bb31d439c Mon Sep 17 00:00:00 2001 From: Davide Pastore Date: Mon, 2 Feb 2026 16:09:55 +0000 Subject: [PATCH 3/4] Split operators in multiple files --- language/operators.xml | 2858 +-------------------------- language/operators/arithmetic.xml | 105 + language/operators/array.xml | 143 ++ language/operators/assignment.xml | 249 +++ language/operators/bitwise.xml | 669 +++++++ language/operators/comparison.xml | 536 +++++ language/operators/errorcontrol.xml | 81 + language/operators/execution.xml | 48 + language/operators/increment.xml | 145 ++ language/operators/logical.xml | 109 + language/operators/precedence.xml | 411 ++++ language/operators/string.xml | 41 + language/operators/type.xml | 269 +++ 13 files changed, 2851 insertions(+), 2813 deletions(-) create mode 100644 language/operators/arithmetic.xml create mode 100644 language/operators/array.xml create mode 100644 language/operators/assignment.xml create mode 100644 language/operators/bitwise.xml create mode 100644 language/operators/comparison.xml create mode 100644 language/operators/errorcontrol.xml create mode 100644 language/operators/execution.xml create mode 100644 language/operators/increment.xml create mode 100644 language/operators/logical.xml create mode 100644 language/operators/precedence.xml create mode 100644 language/operators/string.xml create mode 100644 language/operators/type.xml diff --git a/language/operators.xml b/language/operators.xml index 3c86e3452..96d05d7fc 100644 --- a/language/operators.xml +++ b/language/operators.xml @@ -1,2818 +1,50 @@ - + - - Operatori - - Un operatore è un qualcosa che si posiziona tra uno o più valori (od espressioni, - in gergo tecnico) e produce un'altro valore (in modo tale che la costruzione - stessa diventi a sua volta un'espressione). i - - - Gli operatori possono essere raggruppati a seconda del numero di valori che trattano. Gli - operatori unari quali richiedono un solo valore, ad esempio !i - (l'operatore logico noti) oppure - ++ - (l'operatore di autoincremento). - Gli operatori binari accettano due valor, come i familiari - operatori aritmetici - + (più) e - (meno), e la - maggior parte degli operatori disponibili in PHP ricadono in questa categoria. Infine, esiste un - solo operatore - ternario, ? :, che accetta tre valori; viene - normalmente chiamato "l'operatore ternario" (anche se potrebbe - forse essere chiamato più precisamente operatore condizionale). - - - Una lista completa degli operatore è fornita nella sezione - Precedenza degli operatori. - Questa sezione spiega anche la precedenza degli operatori e l'associatività, che stabiliscono - esattamente come le espressioni contenenti differenti operatori sono - valutate ed eseguite. - - - - Precedenza degli operatori - - La precedenza di un operatore specifica come esso tenga legate assieme "strettamente" due - espressioni. Per esempio, nell'espressione 1 + - 5 * 3, la risposta è 16 e non - 18 perché l'operatore di moltiplicazione ("*") - ha una precedenza più alta rispetto all'operatore di addizione ("+"). - Le parentesi possono essere usate per forzare la precedenza, se necessario. Per - esempio: (1 + 5) * 3 viene valutata - 18. - - - Quando gli operatori hanno precedenza identica, la loro associatività decide - come gli operatori sono raggruppati. Per esempio "-" è associativo a sinistra, quindi - 1 - 2 - 3 è raggruppato come (1 - 2) - 3 - e valutato come -4. D'altra parte "=" è - associativo a destra, quindi $a = $b = $c è raggruppato come - $a = ($b = $c). - - - Operatori di uguale precedenza che non sono associativi non possono essere usati - vicini l'uno all'altro, per esempio 1 < 2 > 1 è - illegale in PHP. D'altra parte l'espressione 1 <= 1 == 1 - è legale, perchè l'operatore == ha una minore - precedenza dell'operatore <=. - - - 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 il raggruppamento esplicito piuttosto che fare affidamento - sulla precedenza e sull'associatività implicite degli operatori. - - - La seguente tabella fornisce una lista della precedenza degli operatori con gli - operatori a più alta precedenza elencati prima. Gli operatori presenti nella medesima linea - hanno uguale precedenza, in questi casi la loro associativià decide il raggruppamento. - - Precedenza degli operatori - - - - Associatività - Operatori - Informazioni aggiuntive - - - - - (n/a) - - clone - new - - clone e new - - - destra - ** - operatori aritmetici - - - (n/a) - - + - - - ++ - -- - ~ - (int) - (float) - (string) - (array) - (object) - (bool) - @ - - - aritmetici (unari + e -), - incremento/decremento, - bitwise, - casting del tipo&listendand; - controllo dell'errore - - - - sinistra - instanceof - - tipo - - - - (n/a) - ! - - logici - - - - sinistra - - * - / - % - - - aritmetici - - - - sinistra - - + - - - . - - - aritmetici (binari + e -), - array&listendand; - stringhe (. prima di PHP 8.0.0) - - - - sinistra - - << - >> - - - bit - - - - sinistra - . - - stringhe (a partire da PHP 8.0.0) - - - - non associativi - - < - <= - > - >= - - - confronto - - - - non associativi - - == - != - === - !== - <> - <=> - - - operatori di confronto - - - - sinistra - & - - operatori sui bit&listendand; - riferimenti - - - sinistra - ^ - - operatori sui bit - - - - sinistra - | - - operatori sui bit - - - - sinistra - && - - operatori logici - - - - sinistra - || - - operatori logici - - - - destra - ?? - - null coalescing - - - - non associativi - ? : - - ternari - (associativi a sinistra prima di PHP 8.0.0) - - - - sinistra - - = - += - -= - *= - **= - /= - .= - %= - &= - |= - ^= - <<= - >>= - ??= - - - operatori di assegnazione - - - - (n/a) - yield from - - yield from - - - - (n/a) - yield - - yield - - - - (n/a) - print - print - - - sinistra - and - - operatori logici - - - - sinistra - xor - - operatori logici - - - - sinistra - or - - operatori logici - - - - -
- - - - Associatività - - $a = 5, $b = 5 -?> -]]> - - - - - La precedenza e l'associatività dell'operatore determinano solo come le espressioni - sono raggruppate, esse non specificano un ordine di valutazione. PHP non - specifica (nel caso generale) in quale ordine un'espressione è valutata - e un codice che presuppone uno specifico ordine di valutazione dovrebbe essere evitato, - perchè il comportamento può cambiare tra le versioni di PHP o in base al - codice circostante. - - Ordine di valutazione indefinito - - -]]> - - - - <literal>+</literal>, <literal>-</literal> e <literal>.</literal> hanno la stessa precedenza (prima di PHP 8.0.0) - - -]]> - - &example.outputs; - - - - - - - - Sebbene = abbia una precedenza minore rispetto - alla maggior parte degli altri operatori, PHP permette comunque espressioni - simili alla seguente: if (!$a = foo()), - in questo caso l'output di foo() viene - inserito in $a. - - - - &reftitle.changelog; - - - - - &Version; - &Description; - - - - - 8.0.0 - - La concatenazione delle stringhe (.) ora ha una precedenza inferiore rispetto - all'addizione/sottrazione aritmetica (+ e -) e - lo spostamento bit a bit a sinistra/destra (<< e >>); - precedentemente aveva la stessa precedenza di + e - - e una precedenza superiore a << e >>. - - - - 8.0.0 - - L'operatore ternario (? :) ora è non-associativo; - precedentemente era associativo a sinistra. - - - - 7.4.0 - - Fare affidamento sulla precedenza della concatenazione di stringhe (.) rispetto all' - addizione/sottrazione aritmetica (+ o -) o - lo spostamento bit a bit a sinistra/destra (<< o >>), - ovvero utilizzarli insieme in un'espressione senza parentesi, è deprecato. - - - - 7.4.0 - - Fare affidamento sull'associatività a sinistra dell'operatore ternario (? :), - ovvero annidare più operatori ternari senza parentesi, è deprecato. - - - - - - - - - - Operatori aritmetici - - Ricordate l'aritmetica di base dalla scuola? Questi operatori funzionano esattamente - nello stesso modo. - - - Operatori aritmetici - - - - Esempio - Nome - Risultato - - - - - +$a - Identità - - Conversione di $a in int o - float in modo appropriato. - - - - -$a - Negazione - Opposto di $a. - - - $a + $b - Addizione - La somma di $a e $b. - - - $a - $b - Sottrazione - La differenza di $a e $b. - - - $a * $b - Moltiplicazione - il prodotto di $a e $b. - - - $a / $b - Divisione - Quoziente di $a e $b. - - - $a % $b - Modulo - Il resto di $a diviso da $b. - - - $a ** $b - Elevamento a potenza - Risultato di elevazione $a alla $besima potenza. - - - -
- - L'operatore di divisione ("/") restituisce un valore float a meno che i due operandi - siano interi (oppure stringhe che vengono convertite in interi) e i numeri - siano divisibili, nel qual caso viene restituito un valore intero. Per le - divisioni di interi, vedere intdiv. - - - Gli operandi del modulo sono convertiti in int - prima dell'operazione. Per il modulo di numeri a virgola mobile, vedere - fmod. - - - Il risultato dell'operatore modulo % ha lo stesso segno - del dividendo - ovvero, il risultato di $a % $b - avrà lo stesso segno di $a. Per esempio: - - - -]]> - - - - - &reftitle.seealso; - - - Funzioni matematiche - - - - - - - Operatori di assegnazione - - L'operatore di base dell'assegnazione è "=". Il primo impulso può - essere quello di pensare che corrisponda a "uguale a". Invece questo operatore significa che - l'operando a sinistra assume il valore dell'espressione a - destra (cioè, "assegna il valore a"). - - - Il valore di un'espressione di assegnazione è il valore assegnato. Ovvero - il valore di "$a = 3" è 3. Questo permette di fare qualche - trucchetto: - - - -]]> - - - - - In aggiunta all'operatore di base dell'assegnazione, ci sono gli "operatori - combinati" per tutta l'aritmetica binaria - e gli operatori di stringa - che consentono di usare un valore in un'espressione e poi impostare il suo - valore al risultato di quell'espressione. Per esempio: - - - -]]> - - - - - Si noti che l'assegnazione copia la variabile originale nella nuova - (assegnazione per valore), così i cambiamenti della prima non si verificheranno nell' - altra. Ciò può anche avere rilevanza se si ha bisogno di copiare - un grande array in un ciclo molto stretto. - - - Un'eccezione al comportamento standard dell'assegnazione per valore avviene - con gliobject, che sono assegnati per riferimento. - Gli oggetti possono essere copiati esplicitamente attraverso la keyword clone. - - - - Assegnazione per referimento - - L'assegnazione per riferimento è pure supportato, usando la sintassi - "$var = &$othervar;. - 'Assegnazione per riferimento' significa che entrambe le variabili finiscono con il puntare agli - stessi dati, e nulla è copiato. - - - - Assegnare per riferimento - - -]]> - - - - - L'operatore new - restituisce automaticamente un riferimento, quindi assegnare il risultato di - new per riferimento è un errore. - - - - - -]]> - - &example.outputs; - - - - - - - Ulteriori informazioni sui riferimenti e sul loro uso possono essere trovati - nella sezione del manuale - Spiegazioni sui riferimenti. - - - - - Operatori di Assegnamento Aritmetici - - - - - Esempio - Equivalente - Operazione - - - - - $a += $b - $a = $a + $b - Addizione - - - $a -= $b - $a = $a - $b - Sottrazione - - - $a *= $b - $a = $a * $b - Moltiplicazione - - - $a /= $b - $a = $a / $b - Divisione - - - $a %= $b - $a = $a % $b - Modulo - - - $a **= $b - $a = $a ** $b - Esponenziale - - - - - - - - Operatori di Assegnazione Bit A Bit - - - - - Esempio - Equivalente - Operazione - - - - - $a &= $b - $a = $a & $b - And Bit a Bit - - - $a |= $b - $a = $a | $b - Or Bit a Bit - - - $a ^= $b - $a = $a ^ $b - Xor Bit a Bit - - - $a <<= $b - $a = $a << $b - Shift a Sinistra - - - $a >>= $b - $a = $a >> $b - Shift a Destra - - - - - - - - Altri Operatori di Assegnamento - - - - - Esempio - Equivalente - Operazione - - - - - $a .= $b - $a = $a . $b - Concatenazione di stringhe - - - $a ??= $b - $a = $a ?? $b - Null Coalesce - - - - - - - - &reftitle.seealso; - - - operatori aritmetici - operatori bit a bit - operatori null coalescing - - - - - - - Operatori sui bit - - Gli operatori sui bit permettono la valutazione e manipolazione di specifici - bit in un valore intero. - - - Operatori sui bit - - - - Esempio - Nome - Risultato - - - - - $a & $b - And - Vengono accesi i bit che sono accesi sia in $a che in $b. - - - $a | $b - Or (inclusive or) - Vengono accesi i bit che sono accesi o in $a oppure in $b. - - - $a ^ $b - Xor (exclusive or) - - Vengono accesi i bit che sono accesi in $a o in $b, ma non quelli accesi in entrambe le variabili. - - - - ~ $a - Not - - Vengono accesi i bit che sono spenti in $a, e viceversa - - - - $a << $b - Shift left - - Sposta verso sinistra i bit di $a per $b volte (ogni passo significa - "moltiplica per due") - - - - $a >> $b - Shift right - - Sposta verso destra i bit di $a per $b volte (ogni passo significa - "dividi per due") - - - - -
- - Lo spostamento di bit in PHP è aritmetico. - I bit spostati al di fuori delle estremità sono scartati. - Gli spostamenti a sinistra inseriscono zeri a destra mentre il bit - di segno è scartato sulla sinistra, quindi il segno di un operando - non è conservato. - Gli spostamenti a destra copiano il bit di segno sulla sinistra, - quindi il segno di un operando è conservato. - - - Utilizzare le parentesi per assicurare la - precedenza desiderata. - Per esempio, $a & $b == true valuta - l'equivalenza e poi l'operatore and; mentre - ($a & $b) == true valuta l'operatore and e - poi l'equivalenza. - - - Se entrambi gli operandi per il operatori &, | - e ^ sono stringhe, allora l'operazione verrà - eseguita sui valori ASCII dei caratteri che compongono le stringhe e - il risultato sarà una stringa. In tutti gli altri casi, entrambi gli operandi saranno - convertiti in interi - e il risultato sarà un intero. - - - Se l'operando per l'operatore ~ è una stringa, - l'operazione verrà eseguita sui valori ASCII dei caratteri che compongono - la stringa e il risultato sarà una stringa, altrimenti l'operando e il - risultato saranno trattati come interi. - - - Sia gli operandi che il risultato per gli operatori << - e >> sono sempre trattati come interi. - - - - - -L'opzione ini error_reporting di PHP usa valori imappati sui bit, -fornendo quindi una dimostrazione reale dello spegnimento -dei bit. Per mostrare tutti gli errori, eccettuati gli avvisi, -le istruzioni del file php.ini dicono di usare: -E_ALL & ~E_NOTICE - - - - -Si prende il valore di E_ALL: -00000000000000000111011111111111 -Quindi quello di E_NOTICE... -00000000000000000000000000001000 -... e lo si inverte con ~: -11111111111111111111111111110111 -infine, si usa AND (&) pre trovare i bit che sono accesi -in entrambi i valori: -00000000000000000111011111110111 - - - - -Un altro metodo per ottenere questo risultato è usare XOR (^) -per trovare i bit che sono accesi solo in uno dei due operandi: -E_ALL ^ E_NOTICE - - - - - - - - -error_reporting può essere usata anche per dimostrare come accendere i bit. -Il modo per mostrare solo gli errori e gli errori recuperabili è: -E_ERROR | E_RECOVERABLE_ERROR - - - - -Questo processo combina E_ERROR -00000000000000000000000000000001 -e -00000000000000000001000000000000 -usando l'operatore OR (|) -per recuperare i bit accesi in entrambi i valori: -00000000000000000001000000000001 - - - - - - - Operazioni AND, OR e XOR su interi - - -]]> - - &example.outputs; - - - - - - - - Operazioni XOR su stringhe - - -]]> - - - - - - Spostamento di bit su interi - -> $places; -p($res, $val, '>>', $places, 'copia del bit di segno inserito a sinistra'); - -$val = 4; -$places = 2; -$res = $val >> $places; -p($res, $val, '>>', $places); - -$val = 4; -$places = 3; -$res = $val >> $places; -p($res, $val, '>>', $places, 'i bit escono dal lato destro'); - -$val = 4; -$places = 4; -$res = $val >> $places; -p($res, $val, '>>', $places, 'come sopra; non c'è spostamento oltre lo 0'); - - -echo "\n--- SPOSTAMENTO A SINISTRA SU INTERI NEGATIVI ---\n"; - -$val = -4; -$places = 1; -$res = $val >> $places; -p($res, $val, '>>', $places, 'copia del bit di segno inserito a sinistra'); - -$val = -4; -$places = 2; -$res = $val >> $places; -p($res, $val, '>>', $places, 'i bit escono dal lato destro'); - -$val = -4; -$places = 3; -$res = $val >> $places; -p($res, $val, '>>', $places, 'come sopra; non c'è spostamento oltre il -1'); - - -echo "\n--- SPOSTAMENTO A SINISTRA SU INTERI POSITIVI ---\n"; - -$val = 4; -$places = 1; -$res = $val << $places; -p($res, $val, '<<', $places, 'zeri inseriti a destra'); - -$val = 4; -$places = (PHP_INT_SIZE * 8) - 4; -$res = $val << $places; -p($res, $val, '<<', $places); - -$val = 4; -$places = (PHP_INT_SIZE * 8) - 3; -$res = $val << $places; -p($res, $val, '<<', $places, 'i bit di segno sono spostati'); - -$val = 4; -$places = (PHP_INT_SIZE * 8) - 2; -$res = $val << $places; -p($res, $val, '<<', $places, 'i bit escono dal lato sinistro'); - - -echo "\n--- SPOSTAMENTO A SINISTRA SU INTERI NEGATIVI ---\n"; - -$val = -4; -$places = 1; -$res = $val << $places; -p($res, $val, '<<', $places, 'zeri inseriti a destra'); - -$val = -4; -$places = (PHP_INT_SIZE * 8) - 3; -$res = $val << $places; -p($res, $val, '<<', $places); - -$val = -4; -$places = (PHP_INT_SIZE * 8) - 2; -$res = $val << $places; -p($res, $val, '<<', $places, 'i bit escono dal lato sinistro, incluso il bit di segno'); - - -/* - * Ignorare questa sezione finale, - * server solo a formattare per rendere più leggibile il risultato. - */ - -function p($res, $val, $op, $places, $note = '') { - $format = '%0' . (PHP_INT_SIZE * 8) . "b\n"; - - printf("Espressione: %d = %d %s %d\n", $res, $val, $op, $places); - - echo " Decimale:\n"; - printf(" val=%d\n", $val); - printf(" res=%d\n", $res); - - echo " Binario:\n"; - printf(' val=' . $format, $val); - printf(' res=' . $format, $res); - - if ($note) { - echo " NOTA: $note\n"; - } - - echo "\n"; -} -?> -]]> - - &example.outputs.32bit; - -> 1 - Decimale: - val=4 - res=2 - Binario: - val=00000000000000000000000000000100 - res=00000000000000000000000000000010 - NOTA: copia del bit di segno inserito a sinistra - -Espressione: 1 = 4 >> 2 - Decimale: - val=4 - res=1 - Binario: - val=00000000000000000000000000000100 - res=00000000000000000000000000000001 - -Espressione: 0 = 4 >> 3 - Decimale: - val=4 - res=0 - Binario: - val=00000000000000000000000000000100 - res=00000000000000000000000000000000 - NOTA: i bit escono dal lato destro - -Espressione: 0 = 4 >> 4 - Decimale: - val=4 - res=0 - Binario: - val=00000000000000000000000000000100 - res=00000000000000000000000000000000 - NOTA: come sopra; non c'è spostamento oltre lo 0 - - ---- SPOSTAMENTO A DESTRA SU INTERI NEGATIVI --- -Espressione: -2 = -4 >> 1 - Decimale: - val=-4 - res=-2 - Binario: - val=11111111111111111111111111111100 - res=11111111111111111111111111111110 - NOTA: copia del bit di segno inserito a sinistra - -Espressione: -1 = -4 >> 2 - Decimale: - val=-4 - res=-1 - Binario: - val=11111111111111111111111111111100 - res=11111111111111111111111111111111 - NOTA: i bit escono dal lato destro - -Espressione: -1 = -4 >> 3 - Decimale: - val=-4 - res=-1 - Binario: - val=11111111111111111111111111111100 - res=11111111111111111111111111111111 - NOTA: come sopra; non c'è spostamento oltre il -1 - - ---- SPOSTAMENTO A SINISTRA SU INTERI POSITIVI --- -Espressione: 8 = 4 << 1 - Decimale: - val=4 - res=8 - Binario: - val=00000000000000000000000000000100 - res=00000000000000000000000000001000 - NOTA: zeri inseriti a destra - -Espressione: 1073741824 = 4 << 28 - Decimale: - val=4 - res=1073741824 - Binario: - val=00000000000000000000000000000100 - res=01000000000000000000000000000000 - -Espressione: -2147483648 = 4 << 29 - Decimale: - val=4 - res=-2147483648 - Binario: - val=00000000000000000000000000000100 - res=10000000000000000000000000000000 - NOTA:i bit di segno sono spostati - -Espressione: 0 = 4 << 30 - Decimale: - val=4 - res=0 - Binario: - val=00000000000000000000000000000100 - res=00000000000000000000000000000000 - NOTA: i bit escono dal lato sinistro - - ---- SPOSTAMENTO A SINISTRA SU INTERI NEGATIVI --- -Espressione: -8 = -4 << 1 - Decimale: - val=-4 - res=-8 - Binario: - val=11111111111111111111111111111100 - res=11111111111111111111111111111000 - NOTA: zeri inseriti a destra - -Espressione: -2147483648 = -4 << 29 - Decimale: - val=-4 - res=-2147483648 - Binario: - val=11111111111111111111111111111100 - res=10000000000000000000000000000000 - -Espressione: 0 = -4 << 30 - Decimale: - val=-4 - res=0 - Binario: - val=11111111111111111111111111111100 - res=00000000000000000000000000000000 - NOTA: i bit escono dal lato sinistro, incluso il bit di segno -]]> - - &example.outputs.64bit; - -> 1 - Decimale: - val=4 - res=2 - Binario: - val=0000000000000000000000000000000000000000000000000000000000000100 - res=0000000000000000000000000000000000000000000000000000000000000010 - NOTA: copia del bit di segno inserito a sinistra - -Espressione: 1 = 4 >> 2 - Decimale: - val=4 - res=1 - Binario: - val=0000000000000000000000000000000000000000000000000000000000000100 - res=0000000000000000000000000000000000000000000000000000000000000001 - -Espressione: 0 = 4 >> 3 - Decimale: - val=4 - res=0 - Binario: - val=0000000000000000000000000000000000000000000000000000000000000100 - res=0000000000000000000000000000000000000000000000000000000000000000 - NOTA: i bit escono dal lato destro - -Espressione: 0 = 4 >> 4 - Decimale: - val=4 - res=0 - Binario: - val=0000000000000000000000000000000000000000000000000000000000000100 - res=0000000000000000000000000000000000000000000000000000000000000000 - NOTA: come sopra; non c'è spostamento oltre lo 0 - - ---- SPOSTAMENTO A DESTRA SU INTERI NEGATIVI --- -Espressione: -2 = -4 >> 1 - Decimale: - val=-4 - res=-2 - Binario: - val=1111111111111111111111111111111111111111111111111111111111111100 - res=1111111111111111111111111111111111111111111111111111111111111110 - NOTA: copia del bit di segno inserito a sinistra - -Espressione: -1 = -4 >> 2 - Decimale: - val=-4 - res=-1 - Binario: - val=1111111111111111111111111111111111111111111111111111111111111100 - res=1111111111111111111111111111111111111111111111111111111111111111 - NOTA: i bit escono dal lato destro - -Espressione: -1 = -4 >> 3 - Decimale: - val=-4 - res=-1 - Binario: - val=1111111111111111111111111111111111111111111111111111111111111100 - res=1111111111111111111111111111111111111111111111111111111111111111 - NOTA: come sopra; non c'è spostamento oltre il -1 - - ---- SPOSTAMENTO A SINISTRA SU INTERI POSITIVI --- -Espressione: 8 = 4 << 1 - Decimale: - val=4 - res=8 - Binario: - val=0000000000000000000000000000000000000000000000000000000000000100 - res=0000000000000000000000000000000000000000000000000000000000001000 - NOTA: zeri inseriti a destra - -Espressione: 4611686018427387904 = 4 << 60 - Decimale: - val=4 - res=4611686018427387904 - Binario: - val=0000000000000000000000000000000000000000000000000000000000000100 - res=0100000000000000000000000000000000000000000000000000000000000000 - -Espressione: -9223372036854775808 = 4 << 61 - Decimale: - val=4 - res=-9223372036854775808 - Binario: - val=0000000000000000000000000000000000000000000000000000000000000100 - res=1000000000000000000000000000000000000000000000000000000000000000 - NOTA: i bit di segno sono spostati - -Espressione: 0 = 4 << 62 - Decimale: - val=4 - res=0 - Binario: - val=0000000000000000000000000000000000000000000000000000000000000100 - res=0000000000000000000000000000000000000000000000000000000000000000 - NOTA: i bit escono dal lato sinistro - - ---- SPOSTAMENTO A SINISTRA SU INTERI NEGATIVI --- -Espressione: -8 = -4 << 1 - Decimale: - val=-4 - res=-8 - Binario: - val=1111111111111111111111111111111111111111111111111111111111111100 - res=1111111111111111111111111111111111111111111111111111111111111000 - NOTA: zeri inseriti a destra - -Espressione: -9223372036854775808 = -4 << 61 - Decimale: - val=-4 - res=-9223372036854775808 - Binario: - val=1111111111111111111111111111111111111111111111111111111111111100 - res=1000000000000000000000000000000000000000000000000000000000000000 - -Espressione: 0 = -4 << 62 - Decimale: - val=-4 - res=0 - Binario: - val=1111111111111111111111111111111111111111111111111111111111111100 - res=0000000000000000000000000000000000000000000000000000000000000000 - NOTA: i bit escono dal lato sinistro, incluso il bit di segno -]]> - - - - - - Utilizzare le funzioni dell'estensione gmp per - manipolazioni bit a bit su numeri che vanno oltre il valore di PHP_INT_MAX. - - - - - &reftitle.seealso; - - - - pack - unpack - gmp_and - gmp_or - gmp_xor - gmp_testbit - gmp_clrbit - - - - - - - Operatori di confronto - - Gli operatori di confronto, come suggerisce il loro nome, permettono di confrontare - due valori. Può essere interessante vedere la - tabella di raffronto dei tipi, - dato che mostra esempi di vari confronti tra i tipi di variabili. - - - Operatori di confronto - - - - Esempio - Nome - Risultato - - - - - $a == $b - Uguale - &true; se $a è uguale a $b dopo la manipolazione dei tipi. - - - $a === $b - Identico - - &true; se $a è uguale a $b, ed sono dello stesso - tipo. - - - - $a != $b - Diversi - &true; se $a è diverso da $b dopo la manipolazione dei tipi. - - - $a <> $b - Diversi - &true; se $a è diverso da $b dopo la manipolazione dei tipi. - - - $a !== $b - Non identici - - &true; se $a è diverso da $b, o se non sono dello stesso - tipo. - - - - $a < $b - Minore - &true; se $a è strettamente minore di $b. - - - $a > $b - Maggiore - &true; se $a è strettamente maggiore di $b. - - - $a <= $b - Minore o uguale - &true; se $a è minore o uguale a $b. - - - $a >= $b - Maggiore o uguale - &true; se $a è maggiore o uguale a $b. - - - $a <=> $b - Spaceship - - Un int minore di, uguale a, o maggiore di zero quando - $a è minore di, uguale a, o maggiore di - $b. - - - - -
- - Se entrambi gli operandi sono - stringhe numeriche - o un operando è un numero e l'altro è una - stringa numerica, - quindi il confronto viene eseguito numericamente. - Queste regole si applicano anche all' - istruzione switch. - La conversione del tipo non ha luogo quando il confronto è - === o !== poiché implica - il confronto del tipo e del valore. - - - - - Prima di PHP 8.0.0, se una stringa veniva confrontata con un numero - o una stringa numerica, la stringa veniva convertita in un - numero prima di eseguire il confronto. Questo può portare a risultati - sorprendenti, come si può vedere con il seguente esempio: - - - -]]> - - &example.outputs.7; - - - - &example.outputs.8; - - - - - - - - - - - 1; // 0 -echo 1 <=> 2; // -1 -echo 2 <=> 1; // 1 - -// Numeri float -echo 1.5 <=> 1.5; // 0 -echo 1.5 <=> 2.5; // -1 -echo 2.5 <=> 1.5; // 1 - -// Stringhe -echo "a" <=> "a"; // 0 -echo "a" <=> "b"; // -1 -echo "b" <=> "a"; // 1 - -echo "a" <=> "aa"; // -1 -echo "zz" <=> "aa"; // 1 - -// Array -echo [] <=> []; // 0 -echo [1, 2, 3] <=> [1, 2, 3]; // 0 -echo [1, 2, 3] <=> []; // 1 -echo [1, 2, 3] <=> [1, 2, 1]; // 1 -echo [1, 2, 3] <=> [1, 2, 4]; // -1 - -// Oggetti -$a = (object) ["a" => "b"]; -$b = (object) ["a" => "b"]; -echo $a <=> $b; // 0 - -$a = (object) ["a" => "b"]; -$b = (object) ["a" => "c"]; -echo $a <=> $b; // -1 - -$a = (object) ["a" => "c"]; -$b = (object) ["a" => "b"]; -echo $a <=> $b; // 1 - -// non vengono confrontati solo i valori; le chiavi devono corrispondere -$a = (object) ["a" => "b"]; -$b = (object) ["b" => "b"]; -echo $a <=> $b; // 1 - -?> -]]> - - - - - - - Se i tipi di operandi utilizzati differiscono, il confronto viene svolto - nell'ordine indicato della seguente tabella. - - - Confronti con differenti tipi - - - - Tipo dell'operando 1 - Tipo dell'operando 2 - Risultato - - - - - null oppure string - string - Si converte &null; in "", confronto numerico o lessicale - - - bool oppure null - qualsiasi - Converte entrambi i lati in bool, &false; < &true; - - - object - object - Le classi predefinite possono avere la propria funzione di confronto, classi differenti - non sono confrontabili, per la stessa classe vedere Confronto di Oggetti. - - - - string, resource, int oppure float - string, resource, int oppure float - Stringhe e risorse sono converti in numeri, confronto matematico - - - array - array - La matrice con meno membri è più piccola, se la chiave dell'operando 1 non si - trova nell'operando 2 allora le matrici non si possono confrontare, in altri casi - il confronto avviene valore per valore (vedere l'esempio seguente) - - - object - qualsiasi - object è sempre più grande - - - array - qualsiasi - array è sempre più grande - - - -
- - - - Confronto Boolean/null - - -]]> - - - - - - - Trascrizione del confronto standard tra matrici - - count($op2)) { - return 1; // $op1 > $op2 - } - foreach ($op1 as $key => $val) { - if (!array_key_exists($key, $op2)) { - return 1; - } elseif ($val < $op2[$key]) { - return -1; - } elseif ($val > $op2[$key]) { - return 1; - } - } - return 0; // $op1 == $op2 -} -?> -]]> - - - - - - Confronto di numeri in virgola mobile - - - A causa del modo in cui i float sono rappresentati internamente al PHP, non - si dovrebbe esaminare l'eguaglianza di due float. - - - - Per maggior informazioni, fare riferimento alla documentazione del tipo float. - - - - - - Tenere presente che la manipolazione dei tipi di PHP non è sempre ovvia quando si confrontano valori di tipi diversi, - in particolare confrontando &integer; con &boolean; o &integer; con &string;. È quindi generalmente - consigliabile utilizzare confronti === e !== piuttosto che - == e != nella maggior parte dei casi. - - - - - Incomparable Values - - Mentre il confronto di identità (=== e !==) - può essere applicato a valori arbitrari, gli altri operatori di confronto dovrebbero essere applicati - solo a valori comparabili. Il risultato del confronto di valori incomparabili non - è definito e non dovrebbe essere considerato attendibile. - - - - - &reftitle.seealso; - - - strcasecmp - strcmp - Operatori degli array - Tipi - - - - - - Operatore ternario - - Un altro operatore condizionale è l'operatore ternario "?:". - - Assegnazione di un valore di default - - -]]> - - - L'espressione (espressione1) ? (espressione2) : (espressione3) - vale espressione2 se - espressione1 è &true;, e - espressione3 se - espressione1 è &false;. - - - È possibile tralasciare l'elemento centrale dell'operatore ternario. - L'espressione espressione1 ?: espressione3 viene valutata - al risultato di espressione1 se espressione1 - viene valutata &true;, e espressione3 in caso contrario. - espressione1 viene valutata solo una volta. - - - - Si noti che l'operatore ternario è un'espressione, e non viene valutato - come variabile, ma come risultato di un'espressione. Questo - è importante da sapere nel caso si desideri restituire una variabile per riferimento. - La riga return $var == 42 ? $a : $b; in una funzione - che restituisce per riferimento non funzionerà e genererà un - avvertimento. - - - - - Si raccomanda di evitare di "sovrapporre" espressioni ternarie. - Il comportamento di PHP quando si utilizza più di un operatore ternario senza parentesi all'interno di una singola - espressione non è ovvio rispetto ad altri linguaggi. - In effetti, prima di PHP 8.0.0, le espressioni ternarie venivano valutate associative a sinistra, - anziché associative a destra come la maggior parte degli altri linguaggi di programmazione. - Fare affidamento sull'associatività di sinistra è deprecato a partire da PHP 7.4.0. - A partire da PHP 8.0.0, l'operatore ternario non è associativo. - - Comportamento ternario non ovvio - - -]]> - - - - - - - Il concatenamento di ternari brevi (?:), tuttavia, è stabile e si comporta in modo ragionevole. - Verrà valutato al primo argomento valutato come valore non falso. Si noti che i valori non - definiti genereranno comunque un avviso. - - Concatenamento ternario breve - - -]]> - - - - - - - - L'operatore Null Coalescing - - Un altro utile operatore abbreviato è il "??" (o null coalescing). - - Assegnazione di un valore predefinito - - -]]> - - - L'espressione (expr1) ?? (expr2) viene valutata a - expr2 se expr1 è - &null;, e expr1 in caso contrario. - - - In particolare, questo operatore non emette un avviso o un avvertimento se il valore del lato - sinistro non esiste, proprio come isset. Questo è particolarmente - utile sulle chiavi degli array. - - - - Si prega di notare che l'operatore null coalescing è un'espressione, e che essa - non viene valutata ad una variabile, ma al risultato di un'espressione. Questo - è importante da sapere nel caso in cui si volesse restituire una variabile per riferimento. - L'istruzione return $foo ?? $bar; in una funzione - che restituisce un riferimento quindi non funzionerà e verrà emesso un - avviso. - - - - - L'operatore null coalescing ha una precedenza bassa. Ciò significa che se lo si mescola - con altri operatori (come la concatenazione di stringhe o gli operatori aritmetici) - saranno probabilmente necessarie parentesi. - - - -]]> - - - - - Si prega di notare che l'operatore null coalescing permette semplici nidificazioni: - - Operatore null coalescing nidificato - - -]]> - - - - - - - - - Operatori di controllo errori - - PHP supporta un operatore di controllo dell'errore: il carattere at (@). - Quando viene anteposto ad una espressione in PHP, qualunque messaggio di errore che possa - essere generato da quella espressione sarà soppresso. - - - Se è stata assegnata una funzione personalizzata di gestione degli errori con - set_error_handler questa verrà comunque chiamata, anche se - la diagnostica è stata soppressa. - - - - - Prima di PHP 8.0.0, la funzione error_reporting chiamata all'interno del gestore di errori personalizzato - restituiva sempre 0 se l'errore veniva soppresso dall'operatore @. - A partire da PHP 8.0.0, restituisce il valore E_ERROR | E_CORE_ERROR | E_COMPILE_ERROR | E_USER_ERROR | E_RECOVERABLE_ERROR | E_PARSE. - - - - - Qualsiasi messaggio di errore generato dall'espressione è disponibile nell'elemento - "message" dell'array restituito da error_get_last. - Il risultato di quella funzione cambierà ad ogni errore, quindi deve essere controllato in anticipo. - - - - - -]]> - - - - - - L'operatore @ funziona solo sulle - espressioni. - Una semplice regola è: se si può ottenere il valore di qualcosa, - allora si può anteporre ad esso l'operatore @. - Per esempio, si può anteporre a variabili, chiamate di funzioni, - determinate chiamate di costrutti di linguaggio (per esempio include), - e così via. - Non si può anteporre a definizioni di funzioni o classi, - o strutture condizionali come if e - foreach, e così via. - - - - - Prima di PHP 8.0.0, era possibile per l'operatore @ - disabilitare gli errori critici che interrompevano l'esecuzione dello script. - Ad esempio, anteporre @ ad una chiamata di una funzione - che non esiste, non essendo disponibile o digitata in modo errato, causerebbe - il termine dello script senza alcuna indicazione sul perché. - - - - - &reftitle.seealso; - - - error_reporting - Funzioni di Gestione degli Errori e Logging - - - - - - - Operatori di esecuzione - - PHP supporta un operatore di esecuzione: backticks (``). Si noti che - non sono apostrofi o apici! PHP cercherà di eseguire - il contenuto dei backticks come comando di shell; sarà restituito l'output - (ovvero, non sarà semplicemente inviato all'output, ma potrà - essere assegnato ad una variabile). L'uso dell'operatore backtick è identico - alla funzione shell_exec. - - -$output"; -?> -]]> - - - - - - L'operatore backtick è disabilitato quando - è disabilitata shell_exec. - - - - - Diversamente da altri linguaggi, i backtick non hanno un significato speciale - all'interno di stringhe delimitate da doppi apici. - - - - - &reftitle.seealso; - - - Funzioni per l'Esecuzione di Programmi - popen - proc_open - Utilizzo di PHP da linea di comando - - - - - - - Operatori di incremento/decremento - - PHP supporta lo stile C degli operatori di pre- e post-incremento - e decremento. - - - - Gli operatori di incremento e decremento agiscono solo su numeri e stringhe. - Array, oggetti, booleani e risorse non ne sono interessati. - Anche decrementare il valore &null; non ha effetti, ma incrementarlo - darà come risultato 1. - - - - Operatori di incremento/decremento - - - - Esempio - Nome - Effetto - - - - - ++$a - Pre-incremento - Incrementa $a di una unità, quindi restituisce $a. - - - $a++ - Post-incremento - Restituisce $a, quindi incrementa $a di una unità. - - - --$a - Pre-decremento - Decrementa $a di una unità, quindi restituisce $a. - - - $a-- - Post-decremento - Restituisce $a, quindi decrementa $a di una unità. - - - -
- - Un semplice script di esempio: - - -Postincrement"; -$a = 5; -echo "Dovrebbe essere 5: " . $a++ . "
\n"; -echo "Dovrebbe essere 6: " . $a . "
\n"; - -echo "

Pre-incremento

"; -$a = 5; -echo "Dovrebbe essere 6: " . ++$a . "
\n"; -echo "Dovrebbe essere 6: " . $a . "
\n"; - -echo "

Post-decremento

"; -$a = 5; -echo "Dovrebbe essere 5: " . $a-- . "
\n"; -echo "Dovrebbe essere 4: " . $a . "
\n"; - -echo "

Pre-decremento

"; -$a = 5; -echo "Dovrebbe essere 4: " . --$a . "
\n"; -echo "Dovrebbe essere 4: " . $a . "
\n"; -?> -]]> - - - - - Il PHP segue le convenzioni di Perl e non del C quando tratta le operazioni matematiche - sui caratteri. Ad esempio, in PHP e Perl - $a = 'Z'; $a++; modifica $a in 'AA', mentre in C - a = 'Z'; a++; modifica a in '[' - (il valore ASCII di 'Z' è 90, quello di '[' è 91). - Si noti che le variabili carattere possono essere incrementate ma non decrementate e - anche in questo caso solo i caratteri e i numeri ASCII (a-z, A-Z e 0-9) sono supportati. - Incrementare/decrementare altre variabili di carattere non ha effetto, la - stringa originale non viene modificata. - - Operazioni aritmetiche su variabili carattere - - -]]> - - &example.outputs; - - - - - - - Incrementare o decrementare valori booleani non ha effetto. - - - - - Operatori logici - - - Operatori logici - - - - Esempio - Nome - Risultato - - - - - $a and $b - And - &true; se $a e $b sono entrambe &true;. - - - $a or $b - Or - &true; se $a o $b è &true;. - - - $a xor $b - Xor - &true; se $a o $b è &true;, ma non entrambe. - - - ! $a - Not - &true; se $a non è &true;. - - - $a && $b - And - &true; se $a e $b sono entrambe &true;. - - - $a || $b - Or - &true; se $a o $b è &true;. - - - -
- - La ragione per le due differenti variazioni degli operatori "and" e "or" - è che operano con differenti precedenze. (Vedere - Precedenza degli - operatori.) - - - Dimostrazione degli operatori logici - - -]]> - - &example.outputs.similar; - - - - - - - - Operatori di stringa - - Ci sono due operatori di stringa. Il primo è l'operatore di - concatenazione ('.'), che restituisce la concatenazione dei suoi argomenti di destra e - di sinistra. Il secondo è l'operatore di - assegnazione concatenato ('.='), che accoda l'argomento sul lato destro all'argomento sul lato - sinistro. Vedere Operatori di - assegnazione per maggiori informazioni. - - - - - - -]]> - - - - - - &reftitle.seealso; - - - Il tipo Stringa - Funzioni per le stringhe - - - - - - - Operatori per matrici - - Operatori per matrici - - - - Esempio - Nome - Risultato - - - - - $a + $b - Unione - Unione di $a e $b. - - - $a == $b - Uguaglianza - &true; se $a e $b hanno le stesse coppie di chiavi/valori. - - - $a === $b - Identità - &true; se $a e $b hanno le stesse coppie di chiavi/valori nel - medesimo ordine e dl medesimo tipo. - - - $a != $b - Disuguaglianza - &true; se $a non è uguale a $b. - - - $a <> $b - Disuguaglianza - &true; se $a non è uguale a $b. - - - $a !== $b - Non-identità - &true; se $a non è identico a $b. - - - -
- - L'operatore + restituisce la matrice di destra aggiunta - a quella di sinistra; per le chiavi esistenti in entrambe le matrici, vengono usati gli elementi - della matrice di sinistra, e gli elementi duplicati in quella - di destra sono ignorati. - - - - - "apple", "b" => "banana"); -$b = array("a" => "pear", "b" => "strawberry", "c" => "cherry"); - -$c = $a + $b; // Unione di $a e $b -echo "Union of \$a and \$b: \n"; -var_dump($c); - -$c = $b + $a; // Unione di $b e $a -echo "Union of \$b and \$a: \n"; -var_dump($c); - -$a += $b; // Unione di $a += $b è $a e $b -echo "Union of \$a += \$b: \n"; -var_dump($a); -?> -]]> - - - Una volta eseguito, lo script visualizzerà: - - - string(5) "apple" - ["b"]=> - string(6) "banana" - ["c"]=> - string(6) "cherry" -} -Union of $b and $a: -array(3) { - ["a"]=> - string(4) "pear" - ["b"]=> - string(10) "strawberry" - ["c"]=> - string(6) "cherry" -} -Union of $a += $b: -array(3) { - ["a"]=> - string(5) "apple" - ["b"]=> - string(6) "banana" - ["c"]=> - string(6) "cherry" -} -]]> - - - - Gli elementi di una matrice sono uguali nel confronto se hanno le - stesse chiavi e gli stessi valori. - - - - Confrontare le matrici - - "banana", "0" => "apple"); - -var_dump($a == $b); // bool(true) -var_dump($a === $b); // bool(false) -?> -]]> - - - - - - &reftitle.seealso; - - - Il tipo Array - Funzioni per gli array - - - - - - - Operatori di tipi - - instanceof è utilizzato per determinare se una variabile PHP - è un oggetto istanza di una certa - classe: - - Utilizzo di <literal>instanceof</literal> con le classi - - -]]> - - &example.outputs; - - - - - - - instanceof può essere usato anche per determinare se una variabile - è un oggetto istanziato da una classe che eredita da una classe parente: - - Utilizzo di <literal>instanceof</literal> con le classi ereditate - - -]]> - - &example.outputs; - - - - - - - Al fine di controllare se un oggetto non è un instanceof di una classe, si - può usare l'operatore logico not - . - - Utilizzo di <literal>instanceof</literal> per controllare se un oggetto <emphasis>non</emphasis> è - un'instanceof di una classe - - -]]> - - &example.outputs; - - - - - - - Infine, instanceof può essere usato anche per deretmnare se - una variable è un oggetto istanziato da una classe che implementa una - interfaccia: - - Utilizzo di <literal>instanceof</literal> con interfacce - - -]]> - - &example.outputs; - - - - - - - Anche se instanceof è normalmente usata con un nome di classe letterale, - può essere usata con un altro oggetto o con una variabile stringa: - - Utilizzo di <literal>instanceof</literal> con altre variabili - - -]]> - - &example.outputs; - - - - - - - instanceof non genera errori se la variabile che viene controllata non è - un oggetto, ma ritorna semplicemente &false;. Le costanti non erano comunque ammesse - prima di PHP 7.3.0. - - Utilizzo di <literal>instanceof</literal> per controllare altre variabili - - -]]> - - &example.outputs; - - - - - - - A partire da PHP 7.3.0, le costanti sono permesse sul lato sinistro - dell'operatore instanceof. - - Utilizzo di <literal>instanceof</literal> per testare le costanti - - -]]> - - &example.outputs.73; - - - - - - - A partire da PHP 8.0.0, instanceof ora può essere utilizzato con espressioni arbitrarie. - L'espressione deve essere racchiusa tra parentesi e produrre una string. - - - Utilizzo di <literal>instanceof</literal> con un'espressione arbitraria - - -]]> - - &example.outputs.8; - - - - - - - L'operatore instanceof ha una variante funzionale - con la funzione is_a. - - - - &reftitle.seealso; - - - get_class - is_a - - - - - + + Operatori + + Un operatore è un qualcosa che si posiziona tra uno o più valori (od espressioni, + in gergo tecnico) e produce un'altro valore (in modo tale che la costruzione + stessa diventi a sua volta un'espressione). + + + Gli operatori possono essere raggruppati a seconda del numero di valori che trattano. Gli + operatori unari quali richiedono un solo valore, ad esempio !i + (l'operatore logico noti) oppure + ++ + (l'operatore di autoincremento). + Gli operatori binari accettano due valor, come i familiari + operatori aritmetici + + (più) e - (meno), e la + maggior parte degli operatori disponibili in PHP ricadono in questa categoria. Infine, esiste un + solo operatore + ternario, ? :, che accetta tre valori; viene + normalmente chiamato "l'operatore ternario" (anche se potrebbe + forse essere chiamato più precisamente operatore condizionale). + + + Una lista completa degli operatore è fornita nella sezione + Precedenza degli operatori. + Questa sezione spiega anche la precedenza degli operatori e l'associatività, che stabiliscono + esattamente come le espressioni contenenti differenti operatori sono + valutate ed eseguite. + + + &language.operators.precedence; + &language.operators.arithmetic; + &language.operators.increment; + &language.operators.assignment; + &language.operators.bitwise; + &language.operators.comparison; + &language.operators.errorcontrol; + &language.operators.execution; + &language.operators.logical; + &language.operators.string; + &language.operators.array; + &language.operators.type; + + + + + Operatori aritmetici + + Ricordate l'aritmetica di base dalla scuola? Questi operatori funzionano esattamente + nello stesso modo. + + + Operatori aritmetici + + + + Esempio + Nome + Risultato + + + + + +$a + Identità + + Conversione di $a in int o + float in modo appropriato. + + + + -$a + Negazione + Opposto di $a. + + + $a + $b + Addizione + La somma di $a e $b. + + + $a - $b + Sottrazione + La differenza di $a e $b. + + + $a * $b + Moltiplicazione + il prodotto di $a e $b. + + + $a / $b + Divisione + Quoziente di $a e $b. + + + $a % $b + Modulo + Il resto di $a diviso da $b. + + + $a ** $b + Elevamento a potenza + Risultato di elevazione $a alla $besima potenza. + + + +
+ + L'operatore di divisione ("/") restituisce un valore float a meno che i due operandi + siano interi (oppure stringhe che vengono convertite in interi) e i numeri + siano divisibili, nel qual caso viene restituito un valore intero. Per le + divisioni di interi, vedere intdiv. + + + Gli operandi del modulo sono convertiti in int + prima dell'operazione. Per il modulo di numeri a virgola mobile, vedere + fmod. + + + Il risultato dell'operatore modulo % ha lo stesso segno + del dividendo - ovvero, il risultato di $a % $b + avrà lo stesso segno di $a. Per esempio: + + + +]]> + + + + + &reftitle.seealso; + + + Funzioni matematiche + + + + \ No newline at end of file diff --git a/language/operators/array.xml b/language/operators/array.xml new file mode 100644 index 000000000..d3c947ec1 --- /dev/null +++ b/language/operators/array.xml @@ -0,0 +1,143 @@ + + + + + Operatori per matrici + + Operatori per matrici + + + + Esempio + Nome + Risultato + + + + + $a + $b + Unione + Unione di $a e $b. + + + $a == $b + Uguaglianza + &true; se $a e $b hanno le stesse coppie di chiavi/valori. + + + $a === $b + Identità + &true; se $a e $b hanno le stesse coppie di chiavi/valori nel + medesimo ordine e dl medesimo tipo. + + + $a != $b + Disuguaglianza + &true; se $a non è uguale a $b. + + + $a <> $b + Disuguaglianza + &true; se $a non è uguale a $b. + + + $a !== $b + Non-identità + &true; se $a non è identico a $b. + + + +
+ + L'operatore + restituisce la matrice di destra aggiunta + a quella di sinistra; per le chiavi esistenti in entrambe le matrici, vengono usati gli elementi + della matrice di sinistra, e gli elementi duplicati in quella + di destra sono ignorati. + + + + + "apple", "b" => "banana"); +$b = array("a" => "pear", "b" => "strawberry", "c" => "cherry"); + +$c = $a + $b; // Unione di $a e $b +echo "Union of \$a and \$b: \n"; +var_dump($c); + +$c = $b + $a; // Unione di $b e $a +echo "Union of \$b and \$a: \n"; +var_dump($c); + +$a += $b; // Unione di $a += $b è $a e $b +echo "Union of \$a += \$b: \n"; +var_dump($a); +?> +]]> + + + Una volta eseguito, lo script visualizzerà: + + +string(5) "apple" +["b"]=> +string(6) "banana" +["c"]=> +string(6) "cherry" +} +Union of $b and $a: +array(3) { +["a"]=> +string(4) "pear" +["b"]=> +string(10) "strawberry" +["c"]=> +string(6) "cherry" +} +Union of $a += $b: +array(3) { +["a"]=> +string(5) "apple" +["b"]=> +string(6) "banana" +["c"]=> +string(6) "cherry" +} +]]> + + + + Gli elementi di una matrice sono uguali nel confronto se hanno le + stesse chiavi e gli stessi valori. + + + + Confrontare le matrici + + "banana", "0" => "apple"); + +var_dump($a == $b); // bool(true) +var_dump($a === $b); // bool(false) +?> +]]> + + + + + + &reftitle.seealso; + + + Il tipo Array + Funzioni per gli array + + + + \ No newline at end of file diff --git a/language/operators/assignment.xml b/language/operators/assignment.xml new file mode 100644 index 000000000..bfa3ab08e --- /dev/null +++ b/language/operators/assignment.xml @@ -0,0 +1,249 @@ + + + + + Operatori di assegnazione + + L'operatore di base dell'assegnazione è "=". Il primo impulso può + essere quello di pensare che corrisponda a "uguale a". Invece questo operatore significa che + l'operando a sinistra assume il valore dell'espressione a + destra (cioè, "assegna il valore a"). + + + Il valore di un'espressione di assegnazione è il valore assegnato. Ovvero + il valore di "$a = 3" è 3. Questo permette di fare qualche + trucchetto: + + + +]]> + + + + + In aggiunta all'operatore di base dell'assegnazione, ci sono gli "operatori + combinati" per tutta l'aritmetica binaria + e gli operatori di stringa + che consentono di usare un valore in un'espressione e poi impostare il suo + valore al risultato di quell'espressione. Per esempio: + + + +]]> + + + + + Si noti che l'assegnazione copia la variabile originale nella nuova + (assegnazione per valore), così i cambiamenti della prima non si verificheranno nell' + altra. Ciò può anche avere rilevanza se si ha bisogno di copiare + un grande array in un ciclo molto stretto. + + + Un'eccezione al comportamento standard dell'assegnazione per valore avviene + con gliobject, che sono assegnati per riferimento. + Gli oggetti possono essere copiati esplicitamente attraverso la keyword clone. + + + + Assegnazione per referimento + + L'assegnazione per riferimento è pure supportato, usando la sintassi + "$var = &$othervar;. + 'Assegnazione per riferimento' significa che entrambe le variabili finiscono con il puntare agli + stessi dati, e nulla è copiato. + + + + Assegnare per riferimento + + +]]> + + + + + L'operatore new + restituisce automaticamente un riferimento, quindi assegnare il risultato di + new per riferimento è un errore. + + + + + +]]> + + &example.outputs; + + + + + + + Ulteriori informazioni sui riferimenti e sul loro uso possono essere trovati + nella sezione del manuale + Spiegazioni sui riferimenti. + + + + + Operatori di Assegnamento Aritmetici + + + + + Esempio + Equivalente + Operazione + + + + + $a += $b + $a = $a + $b + Addizione + + + $a -= $b + $a = $a - $b + Sottrazione + + + $a *= $b + $a = $a * $b + Moltiplicazione + + + $a /= $b + $a = $a / $b + Divisione + + + $a %= $b + $a = $a % $b + Modulo + + + $a **= $b + $a = $a ** $b + Esponenziale + + + + + + + + Operatori di Assegnazione Bit A Bit + + + + + Esempio + Equivalente + Operazione + + + + + $a &= $b + $a = $a & $b + And Bit a Bit + + + $a |= $b + $a = $a | $b + Or Bit a Bit + + + $a ^= $b + $a = $a ^ $b + Xor Bit a Bit + + + $a <<= $b + $a = $a << $b + Shift a Sinistra + + + $a >>= $b + $a = $a >> $b + Shift a Destra + + + + + + + + Altri Operatori di Assegnamento + + + + + Esempio + Equivalente + Operazione + + + + + $a .= $b + $a = $a . $b + Concatenazione di stringhe + + + $a ??= $b + $a = $a ?? $b + Null Coalesce + + + + + + + + &reftitle.seealso; + + + operatori aritmetici + operatori bit a bit + operatori null coalescing + + + + \ No newline at end of file diff --git a/language/operators/bitwise.xml b/language/operators/bitwise.xml new file mode 100644 index 000000000..24c3255a7 --- /dev/null +++ b/language/operators/bitwise.xml @@ -0,0 +1,669 @@ + + + + + Operatori sui bit + + Gli operatori sui bit permettono la valutazione e manipolazione di specifici + bit in un valore intero. + + + Operatori sui bit + + + + Esempio + Nome + Risultato + + + + + $a & $b + And + Vengono accesi i bit che sono accesi sia in $a che in $b. + + + $a | $b + Or (inclusive or) + Vengono accesi i bit che sono accesi o in $a oppure in $b. + + + $a ^ $b + Xor (exclusive or) + + Vengono accesi i bit che sono accesi in $a o in $b, ma non quelli accesi in entrambe le variabili. + + + + ~ $a + Not + + Vengono accesi i bit che sono spenti in $a, e viceversa + + + + $a << $b + Shift left + + Sposta verso sinistra i bit di $a per $b volte (ogni passo significa + "moltiplica per due") + + + + $a >> $b + Shift right + + Sposta verso destra i bit di $a per $b volte (ogni passo significa + "dividi per due") + + + + +
+ + Lo spostamento di bit in PHP è aritmetico. + I bit spostati al di fuori delle estremità sono scartati. + Gli spostamenti a sinistra inseriscono zeri a destra mentre il bit + di segno è scartato sulla sinistra, quindi il segno di un operando + non è conservato. + Gli spostamenti a destra copiano il bit di segno sulla sinistra, + quindi il segno di un operando è conservato. + + + Utilizzare le parentesi per assicurare la + precedenza desiderata. + Per esempio, $a & $b == true valuta + l'equivalenza e poi l'operatore and; mentre + ($a & $b) == true valuta l'operatore and e + poi l'equivalenza. + + + Se entrambi gli operandi per il operatori &, | + e ^ sono stringhe, allora l'operazione verrà + eseguita sui valori ASCII dei caratteri che compongono le stringhe e + il risultato sarà una stringa. In tutti gli altri casi, entrambi gli operandi saranno + convertiti in interi + e il risultato sarà un intero. + + + Se l'operando per l'operatore ~ è una stringa, + l'operazione verrà eseguita sui valori ASCII dei caratteri che compongono + la stringa e il risultato sarà una stringa, altrimenti l'operando e il + risultato saranno trattati come interi. + + + Sia gli operandi che il risultato per gli operatori << + e >> sono sempre trattati come interi. + + + + + +L'opzione ini error_reporting di PHP usa valori imappati sui bit, +fornendo quindi una dimostrazione reale dello spegnimento +dei bit. Per mostrare tutti gli errori, eccettuati gli avvisi, +le istruzioni del file php.ini dicono di usare: +E_ALL & ~E_NOTICE + + + + +Si prende il valore di E_ALL: +00000000000000000111011111111111 +Quindi quello di E_NOTICE... +00000000000000000000000000001000 +... e lo si inverte con ~: +11111111111111111111111111110111 +infine, si usa AND (&) pre trovare i bit che sono accesi +in entrambi i valori: +00000000000000000111011111110111 + + + + +Un altro metodo per ottenere questo risultato è usare XOR (^) +per trovare i bit che sono accesi solo in uno dei due operandi: +E_ALL ^ E_NOTICE + + + + + + + + +error_reporting può essere usata anche per dimostrare come accendere i bit. +Il modo per mostrare solo gli errori e gli errori recuperabili è: +E_ERROR | E_RECOVERABLE_ERROR + + + + +Questo processo combina E_ERROR +00000000000000000000000000000001 +e +00000000000000000001000000000000 +usando l'operatore OR (|) +per recuperare i bit accesi in entrambi i valori: +00000000000000000001000000000001 + + + + + + + Operazioni AND, OR e XOR su interi + + +]]> + + &example.outputs; + + + + + + + + Operazioni XOR su stringhe + + +]]> + + + + + + Spostamento di bit su interi + +> $places; +p($res, $val, '>>', $places, 'copia del bit di segno inserito a sinistra'); + +$val = 4; +$places = 2; +$res = $val >> $places; +p($res, $val, '>>', $places); + +$val = 4; +$places = 3; +$res = $val >> $places; +p($res, $val, '>>', $places, 'i bit escono dal lato destro'); + +$val = 4; +$places = 4; +$res = $val >> $places; +p($res, $val, '>>', $places, 'come sopra; non c'è spostamento oltre lo 0'); + + +echo "\n--- SPOSTAMENTO A SINISTRA SU INTERI NEGATIVI ---\n"; + +$val = -4; +$places = 1; +$res = $val >> $places; +p($res, $val, '>>', $places, 'copia del bit di segno inserito a sinistra'); + +$val = -4; +$places = 2; +$res = $val >> $places; +p($res, $val, '>>', $places, 'i bit escono dal lato destro'); + +$val = -4; +$places = 3; +$res = $val >> $places; +p($res, $val, '>>', $places, 'come sopra; non c'è spostamento oltre il -1'); + + +echo "\n--- SPOSTAMENTO A SINISTRA SU INTERI POSITIVI ---\n"; + +$val = 4; +$places = 1; +$res = $val << $places; +p($res, $val, '<<', $places, 'zeri inseriti a destra'); + +$val = 4; +$places = (PHP_INT_SIZE * 8) - 4; +$res = $val << $places; +p($res, $val, '<<', $places); + +$val = 4; +$places = (PHP_INT_SIZE * 8) - 3; +$res = $val << $places; +p($res, $val, '<<', $places, 'i bit di segno sono spostati'); + +$val = 4; +$places = (PHP_INT_SIZE * 8) - 2; +$res = $val << $places; +p($res, $val, '<<', $places, 'i bit escono dal lato sinistro'); + + +echo "\n--- SPOSTAMENTO A SINISTRA SU INTERI NEGATIVI ---\n"; + +$val = -4; +$places = 1; +$res = $val << $places; +p($res, $val, '<<', $places, 'zeri inseriti a destra'); + +$val = -4; +$places = (PHP_INT_SIZE * 8) - 3; +$res = $val << $places; +p($res, $val, '<<', $places); + +$val = -4; +$places = (PHP_INT_SIZE * 8) - 2; +$res = $val << $places; +p($res, $val, '<<', $places, 'i bit escono dal lato sinistro, incluso il bit di segno'); + + +/* + * Ignorare questa sezione finale, + * server solo a formattare per rendere più leggibile il risultato. + */ + +function p($res, $val, $op, $places, $note = '') { + $format = '%0' . (PHP_INT_SIZE * 8) . "b\n"; + + printf("Espressione: %d = %d %s %d\n", $res, $val, $op, $places); + + echo " Decimale:\n"; + printf(" val=%d\n", $val); + printf(" res=%d\n", $res); + + echo " Binario:\n"; + printf(' val=' . $format, $val); + printf(' res=' . $format, $res); + + if ($note) { + echo " NOTA: $note\n"; + } + + echo "\n"; +} +?> +]]> + + &example.outputs.32bit; + +> 1 + Decimale: +val=4 +res=2 + Binario: +val=00000000000000000000000000000100 +res=00000000000000000000000000000010 + NOTA: copia del bit di segno inserito a sinistra + +Espressione: 1 = 4 >> 2 + Decimale: +val=4 +res=1 + Binario: +val=00000000000000000000000000000100 +res=00000000000000000000000000000001 + +Espressione: 0 = 4 >> 3 + Decimale: +val=4 +res=0 + Binario: +val=00000000000000000000000000000100 +res=00000000000000000000000000000000 + NOTA: i bit escono dal lato destro + +Espressione: 0 = 4 >> 4 + Decimale: +val=4 +res=0 + Binario: +val=00000000000000000000000000000100 +res=00000000000000000000000000000000 + NOTA: come sopra; non c'è spostamento oltre lo 0 + + +--- SPOSTAMENTO A DESTRA SU INTERI NEGATIVI --- +Espressione: -2 = -4 >> 1 + Decimale: +val=-4 +res=-2 + Binario: +val=11111111111111111111111111111100 +res=11111111111111111111111111111110 + NOTA: copia del bit di segno inserito a sinistra + +Espressione: -1 = -4 >> 2 + Decimale: +val=-4 +res=-1 + Binario: +val=11111111111111111111111111111100 +res=11111111111111111111111111111111 + NOTA: i bit escono dal lato destro + +Espressione: -1 = -4 >> 3 + Decimale: +val=-4 +res=-1 + Binario: +val=11111111111111111111111111111100 +res=11111111111111111111111111111111 + NOTA: come sopra; non c'è spostamento oltre il -1 + + +--- SPOSTAMENTO A SINISTRA SU INTERI POSITIVI --- +Espressione: 8 = 4 << 1 + Decimale: +val=4 +res=8 + Binario: +val=00000000000000000000000000000100 +res=00000000000000000000000000001000 + NOTA: zeri inseriti a destra + +Espressione: 1073741824 = 4 << 28 + Decimale: +val=4 +res=1073741824 + Binario: +val=00000000000000000000000000000100 +res=01000000000000000000000000000000 + +Espressione: -2147483648 = 4 << 29 + Decimale: +val=4 +res=-2147483648 + Binario: +val=00000000000000000000000000000100 +res=10000000000000000000000000000000 + NOTA:i bit di segno sono spostati + +Espressione: 0 = 4 << 30 + Decimale: +val=4 +res=0 + Binario: +val=00000000000000000000000000000100 +res=00000000000000000000000000000000 + NOTA: i bit escono dal lato sinistro + + +--- SPOSTAMENTO A SINISTRA SU INTERI NEGATIVI --- +Espressione: -8 = -4 << 1 + Decimale: +val=-4 +res=-8 + Binario: +val=11111111111111111111111111111100 +res=11111111111111111111111111111000 + NOTA: zeri inseriti a destra + +Espressione: -2147483648 = -4 << 29 + Decimale: +val=-4 +res=-2147483648 + Binario: +val=11111111111111111111111111111100 +res=10000000000000000000000000000000 + +Espressione: 0 = -4 << 30 + Decimale: +val=-4 +res=0 + Binario: +val=11111111111111111111111111111100 +res=00000000000000000000000000000000 + NOTA: i bit escono dal lato sinistro, incluso il bit di segno +]]> + + &example.outputs.64bit; + +> 1 + Decimale: +val=4 +res=2 + Binario: +val=0000000000000000000000000000000000000000000000000000000000000100 +res=0000000000000000000000000000000000000000000000000000000000000010 + NOTA: copia del bit di segno inserito a sinistra + +Espressione: 1 = 4 >> 2 + Decimale: +val=4 +res=1 + Binario: +val=0000000000000000000000000000000000000000000000000000000000000100 +res=0000000000000000000000000000000000000000000000000000000000000001 + +Espressione: 0 = 4 >> 3 + Decimale: +val=4 +res=0 + Binario: +val=0000000000000000000000000000000000000000000000000000000000000100 +res=0000000000000000000000000000000000000000000000000000000000000000 + NOTA: i bit escono dal lato destro + +Espressione: 0 = 4 >> 4 + Decimale: +val=4 +res=0 + Binario: +val=0000000000000000000000000000000000000000000000000000000000000100 +res=0000000000000000000000000000000000000000000000000000000000000000 + NOTA: come sopra; non c'è spostamento oltre lo 0 + + +--- SPOSTAMENTO A DESTRA SU INTERI NEGATIVI --- +Espressione: -2 = -4 >> 1 + Decimale: +val=-4 +res=-2 + Binario: +val=1111111111111111111111111111111111111111111111111111111111111100 +res=1111111111111111111111111111111111111111111111111111111111111110 + NOTA: copia del bit di segno inserito a sinistra + +Espressione: -1 = -4 >> 2 + Decimale: +val=-4 +res=-1 + Binario: +val=1111111111111111111111111111111111111111111111111111111111111100 +res=1111111111111111111111111111111111111111111111111111111111111111 + NOTA: i bit escono dal lato destro + +Espressione: -1 = -4 >> 3 + Decimale: +val=-4 +res=-1 + Binario: +val=1111111111111111111111111111111111111111111111111111111111111100 +res=1111111111111111111111111111111111111111111111111111111111111111 + NOTA: come sopra; non c'è spostamento oltre il -1 + + +--- SPOSTAMENTO A SINISTRA SU INTERI POSITIVI --- +Espressione: 8 = 4 << 1 + Decimale: +val=4 +res=8 + Binario: +val=0000000000000000000000000000000000000000000000000000000000000100 +res=0000000000000000000000000000000000000000000000000000000000001000 + NOTA: zeri inseriti a destra + +Espressione: 4611686018427387904 = 4 << 60 + Decimale: +val=4 +res=4611686018427387904 + Binario: +val=0000000000000000000000000000000000000000000000000000000000000100 +res=0100000000000000000000000000000000000000000000000000000000000000 + +Espressione: -9223372036854775808 = 4 << 61 + Decimale: +val=4 +res=-9223372036854775808 + Binario: +val=0000000000000000000000000000000000000000000000000000000000000100 +res=1000000000000000000000000000000000000000000000000000000000000000 + NOTA: i bit di segno sono spostati + +Espressione: 0 = 4 << 62 + Decimale: +val=4 +res=0 + Binario: +val=0000000000000000000000000000000000000000000000000000000000000100 +res=0000000000000000000000000000000000000000000000000000000000000000 + NOTA: i bit escono dal lato sinistro + + +--- SPOSTAMENTO A SINISTRA SU INTERI NEGATIVI --- +Espressione: -8 = -4 << 1 + Decimale: +val=-4 +res=-8 + Binario: +val=1111111111111111111111111111111111111111111111111111111111111100 +res=1111111111111111111111111111111111111111111111111111111111111000 + NOTA: zeri inseriti a destra + +Espressione: -9223372036854775808 = -4 << 61 + Decimale: +val=-4 +res=-9223372036854775808 + Binario: +val=1111111111111111111111111111111111111111111111111111111111111100 +res=1000000000000000000000000000000000000000000000000000000000000000 + +Espressione: 0 = -4 << 62 + Decimale: +val=-4 +res=0 + Binario: +val=1111111111111111111111111111111111111111111111111111111111111100 +res=0000000000000000000000000000000000000000000000000000000000000000 + NOTA: i bit escono dal lato sinistro, incluso il bit di segno +]]> + + + + + + Utilizzare le funzioni dell'estensione gmp per + manipolazioni bit a bit su numeri che vanno oltre il valore di PHP_INT_MAX. + + + + + &reftitle.seealso; + + + + pack + unpack + gmp_and + gmp_or + gmp_xor + gmp_testbit + gmp_clrbit + + + + \ No newline at end of file diff --git a/language/operators/comparison.xml b/language/operators/comparison.xml new file mode 100644 index 000000000..4498ab86e --- /dev/null +++ b/language/operators/comparison.xml @@ -0,0 +1,536 @@ + + + + + Operatori di confronto + + Gli operatori di confronto, come suggerisce il loro nome, permettono di confrontare + due valori. Può essere interessante vedere la + tabella di raffronto dei tipi, + dato che mostra esempi di vari confronti tra i tipi di variabili. + + + Operatori di confronto + + + + Esempio + Nome + Risultato + + + + + $a == $b + Uguale + &true; se $a è uguale a $b dopo la manipolazione dei tipi. + + + $a === $b + Identico + + &true; se $a è uguale a $b, ed sono dello stesso + tipo. + + + + $a != $b + Diversi + &true; se $a è diverso da $b dopo la manipolazione dei tipi. + + + $a <> $b + Diversi + &true; se $a è diverso da $b dopo la manipolazione dei tipi. + + + $a !== $b + Non identici + + &true; se $a è diverso da $b, o se non sono dello stesso + tipo. + + + + $a < $b + Minore + &true; se $a è strettamente minore di $b. + + + $a > $b + Maggiore + &true; se $a è strettamente maggiore di $b. + + + $a <= $b + Minore o uguale + &true; se $a è minore o uguale a $b. + + + $a >= $b + Maggiore o uguale + &true; se $a è maggiore o uguale a $b. + + + $a <=> $b + Spaceship + + Un int minore di, uguale a, o maggiore di zero quando + $a è minore di, uguale a, o maggiore di + $b. + + + + +
+ + Se entrambi gli operandi sono + stringhe numeriche + o un operando è un numero e l'altro è una + stringa numerica, + quindi il confronto viene eseguito numericamente. + Queste regole si applicano anche all' + istruzione switch. + La conversione del tipo non ha luogo quando il confronto è + === o !== poiché implica + il confronto del tipo e del valore. + + + + + Prima di PHP 8.0.0, se una stringa veniva confrontata con un numero + o una stringa numerica, la stringa veniva convertita in un + numero prima di eseguire il confronto. Questo può portare a risultati + sorprendenti, come si può vedere con il seguente esempio: + + + +]]> + + &example.outputs.7; + + + + &example.outputs.8; + + + + + + + + + + + 1; // 0 +echo 1 <=> 2; // -1 +echo 2 <=> 1; // 1 + +// Numeri float +echo 1.5 <=> 1.5; // 0 +echo 1.5 <=> 2.5; // -1 +echo 2.5 <=> 1.5; // 1 + +// Stringhe +echo "a" <=> "a"; // 0 +echo "a" <=> "b"; // -1 +echo "b" <=> "a"; // 1 + +echo "a" <=> "aa"; // -1 +echo "zz" <=> "aa"; // 1 + +// Array +echo [] <=> []; // 0 +echo [1, 2, 3] <=> [1, 2, 3]; // 0 +echo [1, 2, 3] <=> []; // 1 +echo [1, 2, 3] <=> [1, 2, 1]; // 1 +echo [1, 2, 3] <=> [1, 2, 4]; // -1 + +// Oggetti +$a = (object) ["a" => "b"]; +$b = (object) ["a" => "b"]; +echo $a <=> $b; // 0 + +$a = (object) ["a" => "b"]; +$b = (object) ["a" => "c"]; +echo $a <=> $b; // -1 + +$a = (object) ["a" => "c"]; +$b = (object) ["a" => "b"]; +echo $a <=> $b; // 1 + +// non vengono confrontati solo i valori; le chiavi devono corrispondere +$a = (object) ["a" => "b"]; +$b = (object) ["b" => "b"]; +echo $a <=> $b; // 1 + +?> +]]> + + + + + + + Se i tipi di operandi utilizzati differiscono, il confronto viene svolto + nell'ordine indicato della seguente tabella. + + + Confronti con differenti tipi + + + + Tipo dell'operando 1 + Tipo dell'operando 2 + Risultato + + + + + null oppure string + string + Si converte &null; in "", confronto numerico o lessicale + + + bool oppure null + qualsiasi + Converte entrambi i lati in bool, &false; < &true; + + + object + object + Le classi predefinite possono avere la propria funzione di confronto, classi differenti + non sono confrontabili, per la stessa classe vedere Confronto di Oggetti. + + + + string, resource, int oppure float + string, resource, int oppure float + Stringhe e risorse sono converti in numeri, confronto matematico + + + array + array + La matrice con meno membri è più piccola, se la chiave dell'operando 1 non si + trova nell'operando 2 allora le matrici non si possono confrontare, in altri casi + il confronto avviene valore per valore (vedere l'esempio seguente) + + + object + qualsiasi + object è sempre più grande + + + array + qualsiasi + array è sempre più grande + + + +
+ + + + Confronto Boolean/null + + +]]> + + + + + + + Trascrizione del confronto standard tra matrici + + count($op2)) { + return 1; // $op1 > $op2 + } + foreach ($op1 as $key => $val) { + if (!array_key_exists($key, $op2)) { + return 1; + } elseif ($val < $op2[$key]) { + return -1; + } elseif ($val > $op2[$key]) { + return 1; + } + } + return 0; // $op1 == $op2 +} +?> +]]> + + + + + + Confronto di numeri in virgola mobile + + + A causa del modo in cui i float sono rappresentati internamente al PHP, non + si dovrebbe esaminare l'eguaglianza di due float. + + + + Per maggior informazioni, fare riferimento alla documentazione del tipo float. + + + + + + Tenere presente che la manipolazione dei tipi di PHP non è sempre ovvia quando si confrontano valori di tipi diversi, + in particolare confrontando &integer; con &boolean; o &integer; con &string;. È quindi generalmente + consigliabile utilizzare confronti === e !== piuttosto che + == e != nella maggior parte dei casi. + + + + + Incomparable Values + + Mentre il confronto di identità (=== e !==) + può essere applicato a valori arbitrari, gli altri operatori di confronto dovrebbero essere applicati + solo a valori comparabili. Il risultato del confronto di valori incomparabili non + è definito e non dovrebbe essere considerato attendibile. + + + + + &reftitle.seealso; + + + strcasecmp + strcmp + Operatori degli array + Tipi + + + + + + Operatore ternario + + Un altro operatore condizionale è l'operatore ternario "?:". + + Assegnazione di un valore di default + + +]]> + + + L'espressione (espressione1) ? (espressione2) : (espressione3) + vale espressione2 se + espressione1 è &true;, e + espressione3 se + espressione1 è &false;. + + + È possibile tralasciare l'elemento centrale dell'operatore ternario. + L'espressione espressione1 ?: espressione3 viene valutata + al risultato di espressione1 se espressione1 + viene valutata &true;, e espressione3 in caso contrario. + espressione1 viene valutata solo una volta. + + + + Si noti che l'operatore ternario è un'espressione, e non viene valutato + come variabile, ma come risultato di un'espressione. Questo + è importante da sapere nel caso si desideri restituire una variabile per riferimento. + La riga return $var == 42 ? $a : $b; in una funzione + che restituisce per riferimento non funzionerà e genererà un + avvertimento. + + + + + Si raccomanda di evitare di "sovrapporre" espressioni ternarie. + Il comportamento di PHP quando si utilizza più di un operatore ternario senza parentesi all'interno di una singola + espressione non è ovvio rispetto ad altri linguaggi. + In effetti, prima di PHP 8.0.0, le espressioni ternarie venivano valutate associative a sinistra, + anziché associative a destra come la maggior parte degli altri linguaggi di programmazione. + Fare affidamento sull'associatività di sinistra è deprecato a partire da PHP 7.4.0. + A partire da PHP 8.0.0, l'operatore ternario non è associativo. + + Comportamento ternario non ovvio + + +]]> + + + + + + + Il concatenamento di ternari brevi (?:), tuttavia, è stabile e si comporta in modo ragionevole. + Verrà valutato al primo argomento valutato come valore non falso. Si noti che i valori non + definiti genereranno comunque un avviso. + + Concatenamento ternario breve + + +]]> + + + + + + + + L'operatore Null Coalescing + + Un altro utile operatore abbreviato è il "??" (o null coalescing). + + Assegnazione di un valore predefinito + + +]]> + + + L'espressione (expr1) ?? (expr2) viene valutata a + expr2 se expr1 è + &null;, e expr1 in caso contrario. + + + In particolare, questo operatore non emette un avviso o un avvertimento se il valore del lato + sinistro non esiste, proprio come isset. Questo è particolarmente + utile sulle chiavi degli array. + + + + Si prega di notare che l'operatore null coalescing è un'espressione, e che essa + non viene valutata ad una variabile, ma al risultato di un'espressione. Questo + è importante da sapere nel caso in cui si volesse restituire una variabile per riferimento. + L'istruzione return $foo ?? $bar; in una funzione + che restituisce un riferimento quindi non funzionerà e verrà emesso un + avviso. + + + + + L'operatore null coalescing ha una precedenza bassa. Ciò significa che se lo si mescola + con altri operatori (come la concatenazione di stringhe o gli operatori aritmetici) + saranno probabilmente necessarie parentesi. + + + +]]> + + + + + Si prega di notare che l'operatore null coalescing permette semplici nidificazioni: + + Operatore null coalescing nidificato + + +]]> + + + + + + \ No newline at end of file diff --git a/language/operators/errorcontrol.xml b/language/operators/errorcontrol.xml new file mode 100644 index 000000000..d39c0ec64 --- /dev/null +++ b/language/operators/errorcontrol.xml @@ -0,0 +1,81 @@ + + + + + Operatori di controllo errori + + PHP supporta un operatore di controllo dell'errore: il carattere at (@). + Quando viene anteposto ad una espressione in PHP, qualunque messaggio di errore che possa + essere generato da quella espressione sarà soppresso. + + + Se è stata assegnata una funzione personalizzata di gestione degli errori con + set_error_handler questa verrà comunque chiamata, anche se + la diagnostica è stata soppressa. + + + + + Prima di PHP 8.0.0, la funzione error_reporting chiamata all'interno del gestore di errori personalizzato + restituiva sempre 0 se l'errore veniva soppresso dall'operatore @. + A partire da PHP 8.0.0, restituisce il valore E_ERROR | E_CORE_ERROR | E_COMPILE_ERROR | E_USER_ERROR | E_RECOVERABLE_ERROR | E_PARSE. + + + + + Qualsiasi messaggio di errore generato dall'espressione è disponibile nell'elemento + "message" dell'array restituito da error_get_last. + Il risultato di quella funzione cambierà ad ogni errore, quindi deve essere controllato in anticipo. + + + + + +]]> + + + + + + L'operatore @ funziona solo sulle + espressioni. + Una semplice regola è: se si può ottenere il valore di qualcosa, + allora si può anteporre ad esso l'operatore @. + Per esempio, si può anteporre a variabili, chiamate di funzioni, + determinate chiamate di costrutti di linguaggio (per esempio include), + e così via. + Non si può anteporre a definizioni di funzioni o classi, + o strutture condizionali come if e + foreach, e così via. + + + + + Prima di PHP 8.0.0, era possibile per l'operatore @ + disabilitare gli errori critici che interrompevano l'esecuzione dello script. + Ad esempio, anteporre @ ad una chiamata di una funzione + che non esiste, non essendo disponibile o digitata in modo errato, causerebbe + il termine dello script senza alcuna indicazione sul perché. + + + + + &reftitle.seealso; + + + error_reporting + Funzioni di Gestione degli Errori e Logging + + + + \ No newline at end of file diff --git a/language/operators/execution.xml b/language/operators/execution.xml new file mode 100644 index 000000000..323615005 --- /dev/null +++ b/language/operators/execution.xml @@ -0,0 +1,48 @@ + + + + + Operatori di esecuzione + + PHP supporta un operatore di esecuzione: backticks (``). Si noti che + non sono apostrofi o apici! PHP cercherà di eseguire + il contenuto dei backticks come comando di shell; sarà restituito l'output + (ovvero, non sarà semplicemente inviato all'output, ma potrà + essere assegnato ad una variabile). L'uso dell'operatore backtick è identico + alla funzione shell_exec. + + +$output"; +?> +]]> + + + + + + L'operatore backtick è disabilitato quando + è disabilitata shell_exec. + + + + + Diversamente da altri linguaggi, i backtick non hanno un significato speciale + all'interno di stringhe delimitate da doppi apici. + + + + + &reftitle.seealso; + + + Funzioni per l'Esecuzione di Programmi + popen + proc_open + Utilizzo di PHP da linea di comando + + + + \ No newline at end of file diff --git a/language/operators/increment.xml b/language/operators/increment.xml new file mode 100644 index 000000000..ed468f742 --- /dev/null +++ b/language/operators/increment.xml @@ -0,0 +1,145 @@ + + + + + Operatori di incremento/decremento + + PHP supporta lo stile C degli operatori di pre- e post-incremento + e decremento. + + + + Gli operatori di incremento e decremento agiscono solo su numeri e stringhe. + Array, oggetti, booleani e risorse non ne sono interessati. + Anche decrementare il valore &null; non ha effetti, ma incrementarlo + darà come risultato 1. + + + + Operatori di incremento/decremento + + + + Esempio + Nome + Effetto + + + + + ++$a + Pre-incremento + Incrementa $a di una unità, quindi restituisce $a. + + + $a++ + Post-incremento + Restituisce $a, quindi incrementa $a di una unità. + + + --$a + Pre-decremento + Decrementa $a di una unità, quindi restituisce $a. + + + $a-- + Post-decremento + Restituisce $a, quindi decrementa $a di una unità. + + + +
+ + Un semplice script di esempio: + + +Postincrement"; +$a = 5; +echo "Dovrebbe essere 5: " . $a++ . "
\n"; +echo "Dovrebbe essere 6: " . $a . "
\n"; + +echo "

Pre-incremento

"; +$a = 5; +echo "Dovrebbe essere 6: " . ++$a . "
\n"; +echo "Dovrebbe essere 6: " . $a . "
\n"; + +echo "

Post-decremento

"; +$a = 5; +echo "Dovrebbe essere 5: " . $a-- . "
\n"; +echo "Dovrebbe essere 4: " . $a . "
\n"; + +echo "

Pre-decremento

"; +$a = 5; +echo "Dovrebbe essere 4: " . --$a . "
\n"; +echo "Dovrebbe essere 4: " . $a . "
\n"; +?> +]]> + + + + + Il PHP segue le convenzioni di Perl e non del C quando tratta le operazioni matematiche + sui caratteri. Ad esempio, in PHP e Perl + $a = 'Z'; $a++; modifica $a in 'AA', mentre in C + a = 'Z'; a++; modifica a in '[' + (il valore ASCII di 'Z' è 90, quello di '[' è 91). + Si noti che le variabili carattere possono essere incrementate ma non decrementate e + anche in questo caso solo i caratteri e i numeri ASCII (a-z, A-Z e 0-9) sono supportati. + Incrementare/decrementare altre variabili di carattere non ha effetto, la + stringa originale non viene modificata. + + Operazioni aritmetiche su variabili carattere + + +]]> + + &example.outputs; + + + + + + + Incrementare o decrementare valori booleani non ha effetto. + + \ No newline at end of file diff --git a/language/operators/logical.xml b/language/operators/logical.xml new file mode 100644 index 000000000..3db6d011f --- /dev/null +++ b/language/operators/logical.xml @@ -0,0 +1,109 @@ + + + + + Operatori logici + + + Operatori logici + + + + Esempio + Nome + Risultato + + + + + $a and $b + And + &true; se $a e $b sono entrambe &true;. + + + $a or $b + Or + &true; se $a o $b è &true;. + + + $a xor $b + Xor + &true; se $a o $b è &true;, ma non entrambe. + + + ! $a + Not + &true; se $a non è &true;. + + + $a && $b + And + &true; se $a e $b sono entrambe &true;. + + + $a || $b + Or + &true; se $a o $b è &true;. + + + +
+ + La ragione per le due differenti variazioni degli operatori "and" e "or" + è che operano con differenti precedenze. (Vedere + Precedenza degli + operatori.) + + + Dimostrazione degli operatori logici + + +]]> + + &example.outputs.similar; + + + + + \ No newline at end of file diff --git a/language/operators/precedence.xml b/language/operators/precedence.xml new file mode 100644 index 000000000..6c3e119f5 --- /dev/null +++ b/language/operators/precedence.xml @@ -0,0 +1,411 @@ + + + + + Precedenza degli operatori + + La precedenza di un operatore specifica come esso tenga legate assieme "strettamente" due + espressioni. Per esempio, nell'espressione 1 + + 5 * 3, la risposta è 16 e non + 18 perché l'operatore di moltiplicazione ("*") + ha una precedenza più alta rispetto all'operatore di addizione ("+"). + Le parentesi possono essere usate per forzare la precedenza, se necessario. Per + esempio: (1 + 5) * 3 viene valutata + 18. + + + Quando gli operatori hanno precedenza identica, la loro associatività decide + come gli operatori sono raggruppati. Per esempio "-" è associativo a sinistra, quindi + 1 - 2 - 3 è raggruppato come (1 - 2) - 3 + e valutato come -4. D'altra parte "=" è + associativo a destra, quindi $a = $b = $c è raggruppato come + $a = ($b = $c). + + + Operatori di uguale precedenza che non sono associativi non possono essere usati + vicini l'uno all'altro, per esempio 1 < 2 > 1 è + illegale in PHP. D'altra parte l'espressione 1 <= 1 == 1 + è legale, perchè l'operatore == ha una minore + precedenza dell'operatore <=. + + + 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 il raggruppamento esplicito piuttosto che fare affidamento + sulla precedenza e sull'associatività implicite degli operatori. + + + La seguente tabella fornisce una lista della precedenza degli operatori con gli + operatori a più alta precedenza elencati prima. Gli operatori presenti nella medesima linea + hanno uguale precedenza, in questi casi la loro associativià decide il raggruppamento. + + Precedenza degli operatori + + + + Associatività + Operatori + Informazioni aggiuntive + + + + + (n/a) + + clone + new + + clone e new + + + destra + ** + operatori aritmetici + + + (n/a) + + + + - + ++ + -- + ~ + (int) + (float) + (string) + (array) + (object) + (bool) + @ + + + aritmetici (unari + e -), + incremento/decremento, + bitwise, + casting del tipo&listendand; + controllo dell'errore + + + + sinistra + instanceof + + tipo + + + + (n/a) + ! + + logici + + + + sinistra + + * + / + % + + + aritmetici + + + + sinistra + + + + - + . + + + aritmetici (binari + e -), + array&listendand; + stringhe (. prima di PHP 8.0.0) + + + + sinistra + + << + >> + + + bit + + + + sinistra + . + + stringhe (a partire da PHP 8.0.0) + + + + non associativi + + < + <= + > + >= + + + confronto + + + + non associativi + + == + != + === + !== + <> + <=> + + + operatori di confronto + + + + sinistra + & + + operatori sui bit&listendand; + riferimenti + + + sinistra + ^ + + operatori sui bit + + + + sinistra + | + + operatori sui bit + + + + sinistra + && + + operatori logici + + + + sinistra + || + + operatori logici + + + + destra + ?? + + null coalescing + + + + non associativi + ? : + + ternari + (associativi a sinistra prima di PHP 8.0.0) + + + + sinistra + + = + += + -= + *= + **= + /= + .= + %= + &= + |= + ^= + <<= + >>= + ??= + + + operatori di assegnazione + + + + (n/a) + yield from + + yield from + + + + (n/a) + yield + + yield + + + + (n/a) + print + print + + + sinistra + and + + operatori logici + + + + sinistra + xor + + operatori logici + + + + sinistra + or + + operatori logici + + + + +
+ + + + Associatività + + $a = 5, $b = 5 +?> +]]> + + + + + La precedenza e l'associatività dell'operatore determinano solo come le espressioni + sono raggruppate, esse non specificano un ordine di valutazione. PHP non + specifica (nel caso generale) in quale ordine un'espressione è valutata + e un codice che presuppone uno specifico ordine di valutazione dovrebbe essere evitato, + perchè il comportamento può cambiare tra le versioni di PHP o in base al + codice circostante. + + Ordine di valutazione indefinito + + +]]> + + + + <literal>+</literal>, <literal>-</literal> e <literal>.</literal> hanno la stessa precedenza (prima di PHP 8.0.0) + + +]]> + + &example.outputs; + + + + + + + + Sebbene = abbia una precedenza minore rispetto + alla maggior parte degli altri operatori, PHP permette comunque espressioni + simili alla seguente: if (!$a = foo()), + in questo caso l'output di foo() viene + inserito in $a. + + + + &reftitle.changelog; + + + + + &Version; + &Description; + + + + + 8.0.0 + + La concatenazione delle stringhe (.) ora ha una precedenza inferiore rispetto + all'addizione/sottrazione aritmetica (+ e -) e + lo spostamento bit a bit a sinistra/destra (<< e >>); + precedentemente aveva la stessa precedenza di + e - + e una precedenza superiore a << e >>. + + + + 8.0.0 + + L'operatore ternario (? :) ora è non-associativo; + precedentemente era associativo a sinistra. + + + + 7.4.0 + + Fare affidamento sulla precedenza della concatenazione di stringhe (.) rispetto all' + addizione/sottrazione aritmetica (+ o -) o + lo spostamento bit a bit a sinistra/destra (<< o >>), + ovvero utilizzarli insieme in un'espressione senza parentesi, è deprecato. + + + + 7.4.0 + + Fare affidamento sull'associatività a sinistra dell'operatore ternario (? :), + ovvero annidare più operatori ternari senza parentesi, è deprecato. + + + + + + + \ No newline at end of file diff --git a/language/operators/string.xml b/language/operators/string.xml new file mode 100644 index 000000000..2f00654aa --- /dev/null +++ b/language/operators/string.xml @@ -0,0 +1,41 @@ + + + + + Operatori di stringa + + Ci sono due operatori di stringa. Il primo è l'operatore di + concatenazione ('.'), che restituisce la concatenazione dei suoi argomenti di destra e + di sinistra. Il secondo è l'operatore di + assegnazione concatenato ('.='), che accoda l'argomento sul lato destro all'argomento sul lato + sinistro. Vedere Operatori di + assegnazione per maggiori informazioni. + + + + + + +]]> + + + + + + &reftitle.seealso; + + + Il tipo Stringa + Funzioni per le stringhe + + + + diff --git a/language/operators/type.xml b/language/operators/type.xml new file mode 100644 index 000000000..36cc21c9a --- /dev/null +++ b/language/operators/type.xml @@ -0,0 +1,269 @@ + + + + + Operatori di tipi + + instanceof è utilizzato per determinare se una variabile PHP + è un oggetto istanza di una certa + classe: + + Utilizzo di <literal>instanceof</literal> con le classi + + +]]> + + &example.outputs; + + + + + + + instanceof può essere usato anche per determinare se una variabile + è un oggetto istanziato da una classe che eredita da una classe parente: + + Utilizzo di <literal>instanceof</literal> con le classi ereditate + + +]]> + + &example.outputs; + + + + + + + Al fine di controllare se un oggetto non è un instanceof di una classe, si + può usare l'operatore logico not + . + + Utilizzo di <literal>instanceof</literal> per controllare se un oggetto <emphasis>non</emphasis> è + un'instanceof di una classe + + +]]> + + &example.outputs; + + + + + + + Infine, instanceof può essere usato anche per deretmnare se + una variable è un oggetto istanziato da una classe che implementa una + interfaccia: + + Utilizzo di <literal>instanceof</literal> con interfacce + + +]]> + + &example.outputs; + + + + + + + Anche se instanceof è normalmente usata con un nome di classe letterale, + può essere usata con un altro oggetto o con una variabile stringa: + + Utilizzo di <literal>instanceof</literal> con altre variabili + + +]]> + + &example.outputs; + + + + + + + instanceof non genera errori se la variabile che viene controllata non è + un oggetto, ma ritorna semplicemente &false;. Le costanti non erano comunque ammesse + prima di PHP 7.3.0. + + Utilizzo di <literal>instanceof</literal> per controllare altre variabili + + +]]> + + &example.outputs; + + + + + + + A partire da PHP 7.3.0, le costanti sono permesse sul lato sinistro + dell'operatore instanceof. + + Utilizzo di <literal>instanceof</literal> per testare le costanti + + +]]> + + &example.outputs.73; + + + + + + + A partire da PHP 8.0.0, instanceof ora può essere utilizzato con espressioni arbitrarie. + L'espressione deve essere racchiusa tra parentesi e produrre una string. + + + Utilizzo di <literal>instanceof</literal> con un'espressione arbitraria + + +]]> + + &example.outputs.8; + + + + + + + L'operatore instanceof ha una variante funzionale + con la funzione is_a. + + + + &reftitle.seealso; + + + get_class + is_a + + + + \ No newline at end of file From 36df6cc8e9c437939d2e90018a31f7e0c3f9ba39 Mon Sep 17 00:00:00 2001 From: Davide Pastore Date: Mon, 2 Feb 2026 16:12:13 +0000 Subject: [PATCH 4/4] Sync with EN --- language/operators.xml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/language/operators.xml b/language/operators.xml index 96d05d7fc..ec7880ef3 100644 --- a/language/operators.xml +++ b/language/operators.xml @@ -1,7 +1,7 @@ - + - + Operatori Un operatore è un qualcosa che si posiziona tra uno o più valori (od espressioni, @@ -43,6 +43,7 @@ &language.operators.string; &language.operators.array; &language.operators.type; + &language.operators.functional;