diff --git a/language/operators.xml b/language/operators.xml
index 3c86e3452..ec7880ef3 100644
--- a/language/operators.xml
+++ b/language/operators.xml
@@ -1,2818 +1,51 @@
-
+
-
- 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.
-
-
-
-
- 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 "
";
-$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;
+ &language.operators.functional;
+
+
+
+
+ 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 "
";
+$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.
+
+
+
+
+ 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
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;
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