diff --git a/language/control-structures/declare.xml b/language/control-structures/declare.xml
new file mode 100644
index 000000000..58c1df7e0
--- /dev/null
+++ b/language/control-structures/declare.xml
@@ -0,0 +1,188 @@
+
+
+
+
+ declare
+
+
+ Il costrutto declare è utilizzato per
+ impostare le direttive di esecuzione per un blocco di codice.
+ La sintassi di declare è simile a
+ quella di altri costrutti di controllo del flusso:
+
+
+
+
+
+
+
+
+ La sezione directive consente di impostare
+ il comportamento del blocco declare.
+ Attualmente sono riconosciute solo tre direttive:
+
+ ticks
+ encoding
+ strict_types
+
+
+
+
+ Poiché le direttive vengono gestite durante la compilazione del file, solo
+ i valori letterali possono essere utilizzati come valori delle direttive. Non è possibile utilizzare
+ variabili e costanti. Per illustrare:
+
+
+
+]]>
+
+
+
+
+ La parte statement del blocco
+ declare verrà eseguita - come viene
+ eseguita e quali effetti collaterali si verificano durante l'esecuzione
+ possono dipendere dalla direttiva impostata nel
+ blocco directive.
+
+
+ Il costrutto declare può anche essere utilizzato nello scope
+ globale, influenzando tutto il codice che lo segue (tuttavia se il file con
+ declare è stato incluso, non influenza il file
+ genitore).
+
+
+
+]]>
+
+
+
+
+
+ Tick
+ Un tick è un evento che si verifica per ogni
+ N istruzioni tickabili di basso livello eseguite
+ dal parser all'interno del blocco declare.
+ Il valore di N è specificato
+ usando ticks=N
+ nella sezione directive del blocco
+ declare.
+
+
+ Non tutte le istruzioni sono tickabili. Tipicamente, le espressioni
+ di condizione e le espressioni degli argomenti non sono tickabili.
+
+
+ Gli eventi che si verificano ad ogni tick sono specificati usando la funzione
+ register_tick_function. Vedere l'esempio
+ seguente per maggiori dettagli. È possibile che più di un evento si verifichi
+ per ogni tick.
+
+
+
+ Esempio di utilizzo dei tick
+
+ 0) {
+ $a += 2; // causa un evento tick
+ print $a; // causa un evento tick
+}
+
+?>
+]]>
+
+
+
+
+ Vedere anche register_tick_function e
+ unregister_tick_function.
+
+
+
+ Encoding
+
+ La codifica di uno script può essere specificata per ogni script usando la direttiva encoding.
+
+ Dichiarazione della codifica dello script
+
+
+]]>
+
+
+
+
+
+
+ Quando combinata con i namespace, l'unica sintassi valida per declare
+ è declare(encoding='...'); dove ...
+ è il valore della codifica. declare(encoding='...') {}
+ genererà un errore di parsing quando combinata con i namespace.
+
+
+
+ Vedere anche zend.script_encoding.
+
+
+
+
+
diff --git a/language/control-structures/foreach.xml b/language/control-structures/foreach.xml
new file mode 100644
index 000000000..f6c39982f
--- /dev/null
+++ b/language/control-structures/foreach.xml
@@ -0,0 +1,331 @@
+
+
+
+ foreach
+
+
+ Il costrutto foreach fornisce un modo semplice per
+ iterare su array e oggetti Traversable.
+ foreach genererà un errore se utilizzato con
+ una variabile contenente un tipo di dato diverso o con una variabile non inizializzata.
+
+
+ foreach può opzionalmente ottenere la chiave di ogni elemento:
+
+
+ $value) {
+ statement_list
+}
+]]>
+
+
+
+
+ La prima forma attraversa l'iterabile dato da
+ iterable_expression. Ad ogni iterazione, il valore
+ dell'elemento corrente viene assegnato a $value.
+
+
+ La seconda forma assegnerà inoltre la chiave dell'elemento corrente alla
+ variabile $key ad ogni iterazione.
+
+
+ foreach non modifica il puntatore interno dell'array,
+ che è utilizzato da funzioni come current
+ e key.
+
+
+ È possibile
+ personalizzare l'iterazione degli oggetti.
+
+
+
+ Usi comuni di <literal>foreach</literal>
+
+ 1,
+ "two" => 2,
+ "three" => 3,
+ "seventeen" => 17
+];
+
+foreach ($array as $key => $value) {
+ echo "Key: $key => Value: $value\n";
+}
+
+/* Esempio: array multidimensionali chiave-valore */
+$grid = [];
+$grid[0][0] = "a";
+$grid[0][1] = "b";
+$grid[1][0] = "y";
+$grid[1][1] = "z";
+
+foreach ($grid as $y => $row) {
+ foreach ($row as $x => $value) {
+ echo "Value at position x=$x and y=$y: $value\n";
+ }
+}
+
+/* Esempio: array dinamici */
+foreach (range(1, 5) as $value) {
+ echo "$value\n";
+}
+?>
+]]>
+
+
+
+
+ foreach non supporta la possibilità di
+ sopprimere i messaggi di errore usando
+ @.
+
+
+
+
+ Spacchettamento di array annidati
+
+
+ È possibile iterare su un array di array e spacchettare l'array annidato
+ nelle variabili del ciclo utilizzando la
+ destrutturazione degli array
+ tramite [] o utilizzando il costrutto del linguaggio list
+ come valore.
+
+
+
+ La
+ destrutturazione degli array
+ tramite [] è possibile solo a partire da PHP 7.1.0
+
+
+
+
+
+
+
+ In entrambi gli esempi seguenti $a verrà impostato al
+ primo elemento dell'array annidato e $b conterrà
+ il secondo elemento:
+
+
+
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
+
+ Quando vengono fornite meno variabili di quanti siano gli elementi nell'array,
+ gli elementi rimanenti verranno ignorati.
+ Allo stesso modo, è possibile saltare gli elementi usando una virgola:
+
+
+
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
+
+ Verrà generato un avviso se non ci sono abbastanza elementi nell'array per riempire
+ list:
+
+
+
+
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
+
+
+ foreach e i riferimenti
+
+ È possibile modificare direttamente gli elementi dell'array all'interno di un ciclo
+ facendo precedere $value da &.
+ In tal caso il valore sarà assegnato per
+ riferimento.
+
+
+
+]]>
+
+
+
+
+
+ Il riferimento a un $value dell'ultimo elemento dell'array
+ rimane anche dopo il ciclo foreach. Si raccomanda
+ di distruggerlo usando unset.
+ Altrimenti, si verificherà il seguente comportamento:
+
+
+
+ $value) {
+ // $arr[3] verrà aggiornato con ogni valore di $arr...
+ echo "{$key} => {$value} ";
+ print_r($arr);
+}
+// ...fino a quando il penultimo valore verrà copiato sull'ultimo
+?>
+]]>
+
+ &example.outputs;
+
+ 2 Array ( [0] => 2, [1] => 4, [2] => 6, [3] => 2 )
+1 => 4 Array ( [0] => 2, [1] => 4, [2] => 6, [3] => 4 )
+2 => 6 Array ( [0] => 2, [1] => 4, [2] => 6, [3] => 6 )
+3 => 6 Array ( [0] => 2, [1] => 4, [2] => 6, [3] => 6 )
+]]>
+
+
+
+
+ Iterare i valori di un array costante per riferimento
+
+
+]]>
+
+
+
+
+
+ &reftitle.seealso;
+
+ array
+ Traversable
+ iterable
+ list
+
+
+
+
+
+
diff --git a/language/control-structures/include.xml b/language/control-structures/include.xml
new file mode 100644
index 000000000..beacef09c
--- /dev/null
+++ b/language/control-structures/include.xml
@@ -0,0 +1,337 @@
+
+
+
+
+ include
+
+
+ L'espressione include include e valuta
+ il file specificato.
+
+
+ La documentazione seguente si applica anche a require.
+
+
+ I file vengono inclusi in base al percorso indicato o, se non viene indicato, in base
+ all'include_path specificato. Se il file
+ non viene trovato nell'include_path,
+ include cercherà infine nella directory dello script
+ chiamante e nella directory di lavoro corrente prima di fallire. Il
+ costrutto include emetterà un
+ E_WARNING se
+ non riesce a trovare un file; questo è un comportamento diverso da
+ require, che emetterà un
+ E_ERROR.
+
+
+ Sia include che require
+ generano ulteriori E_WARNING, se il file non può essere
+ acceduto, prima di generare il E_WARNING o
+ E_ERROR finale, rispettivamente.
+
+
+ Se viene definito un percorso — sia assoluto (che inizia con una lettera di unità
+ o \ su Windows, o / su sistemi Unix/Linux)
+ che relativo alla directory corrente (che inizia con
+ . o ..) — l'
+ include_path verrà ignorato
+ completamente. Ad esempio, se un nome di file inizia con ../,
+ il parser cercherà nella directory genitore per trovare il file richiesto.
+
+
+ Per maggiori informazioni su come PHP gestisce l'inclusione dei file e il percorso di inclusione,
+ consultare la documentazione per include_path.
+
+
+ Quando un file viene incluso, il codice che contiene eredita lo
+ scope delle variabili della
+ riga in cui si verifica l'inclusione. Tutte le variabili disponibili a quella riga
+ nel file chiamante saranno disponibili all'interno del file chiamato, da quel
+ punto in poi.
+ Tuttavia, tutte le funzioni e le classi definite nel file incluso hanno
+ scope globale.
+
+
+
+ Esempio base di <literal>include</literal>
+
+
+
+test.php
+
+]]>
+
+
+
+
+ Se l'inclusione avviene all'interno di una funzione nel file chiamante,
+ tutto il codice contenuto nel file chiamato si comporterà come
+ se fosse stato definito all'interno di quella funzione. Quindi, seguirà
+ lo scope delle variabili di quella funzione.
+ Un'eccezione a questa regola sono le costanti magiche che vengono
+ valutate dal parser prima che avvenga l'inclusione.
+
+
+
+ Inclusione all'interno di funzioni
+
+
+]]>
+
+
+
+
+ Quando un file viene incluso, il parsing esce dalla modalità PHP ed
+ entra in modalità HTML all'inizio del file di destinazione, e riprende
+ nuovamente alla fine. Per questo motivo, qualsiasi codice all'interno del file
+ di destinazione che debba essere eseguito come codice PHP deve essere racchiuso tra
+ tag PHP di apertura
+ e chiusura validi.
+
+
+ Se gli "URL include wrapper"
+ sono abilitati in PHP,
+ è possibile specificare il file da includere usando un URL (tramite HTTP o
+ un altro wrapper supportato - consultare per un elenco
+ dei protocolli) invece di un percorso locale. Se il server di destinazione interpreta
+ il file di destinazione come codice PHP, è possibile passare variabili al file incluso
+ usando una stringa di richiesta URL come quella utilizzata con HTTP GET. Questo
+ non è esattamente la stessa cosa che includere il file e fargli ereditare
+ lo scope delle variabili del file genitore; lo script viene effettivamente
+ eseguito sul server remoto e il risultato viene poi
+ incluso nello script locale.
+
+
+
+ <literal>include</literal> tramite HTTP
+
+
+]]>
+
+
+
+
+ Avviso di sicurezza
+
+ Il file remoto potrebbe essere elaborato sul server remoto (a seconda dell'estensione
+ del file e del fatto che il server remoto esegua PHP o meno) ma deve comunque
+ produrre uno script PHP valido perché verrà elaborato sul
+ server locale. Se il file del server remoto deve essere elaborato
+ là e fornire solo l'output, readfile è una funzione
+ molto più adatta da utilizzare. Altrimenti, è necessario prestare particolare attenzione
+ per proteggere lo script remoto affinché produca un codice valido e desiderato.
+
+
+
+ Consultare anche File remoti,
+ fopen e file per informazioni
+ correlate.
+
+
+ Gestione dei valori di ritorno: include restituisce
+ FALSE in caso di fallimento e genera un avviso. Le inclusioni
+ riuscite, a meno che non venga sovrascritto dal file incluso, restituiscono
+ 1. È possibile eseguire un'istruzione return
+ all'interno di un file incluso per terminare l'elaborazione in
+ quel file e tornare allo script che lo ha chiamato. Inoltre, è possibile
+ restituire valori dai file inclusi. È possibile ottenere il valore della
+ chiamata include come per una funzione normale. Questo non è, tuttavia,
+ possibile quando si includono file remoti a meno che l'output del file remoto
+ abbia tag PHP di apertura
+ e chiusura validi (come con qualsiasi file locale). È possibile dichiarare le
+ variabili necessarie all'interno di quei tag e saranno introdotte nel
+ punto in cui il file è stato incluso.
+
+
+ Poiché include è un costrutto speciale del linguaggio,
+ le parentesi non sono necessarie attorno al suo argomento. Prestare attenzione quando
+ si confronta il valore di ritorno.
+
+ Confronto del valore di ritorno di include
+
+
+]]>
+
+
+
+
+
+ <literal>include</literal> e l'istruzione <function>return</function>
+
+
+
+noreturn.php
+
+
+testreturns.php
+
+]]>
+
+
+
+
+ $bar ha il valore 1 perché l'inclusione
+ è riuscita. Notare la differenza tra gli esempi precedenti. Il primo usa
+ return all'interno del file incluso mentre l'altro no.
+ Se il file non può essere incluso, viene restituito &false; e viene
+ emesso un E_WARNING.
+
+
+ Se ci sono funzioni definite nel file incluso, possono essere utilizzate nel
+ file principale indipendentemente dal fatto che siano prima di return o dopo.
+ Se il file viene incluso due volte, PHP genererà un errore fatale perché le
+ funzioni erano già state dichiarate.
+ Si raccomanda di usare include_once invece di
+ verificare se il file è già stato incluso e restituire condizionalmente un valore
+ all'interno del file incluso.
+
+
+ Un altro modo per "includere" un file PHP in una variabile è catturare
+ l'output usando le Funzioni di Controllo
+ dell'Output con include. Ad esempio:
+
+
+
+ Uso del buffering dell'output per includere un file PHP in una stringa
+
+
+]]>
+
+
+
+
+ Per includere automaticamente file all'interno degli script, consultare anche le
+ opzioni di configurazione
+ auto_prepend_file e
+ auto_append_file
+ in &php.ini;.
+
+
+ ¬e.language-construct;
+
+
+ Vedere anche require, require_once,
+ include_once, get_included_files,
+ readfile, virtual e
+ include_path.
+
+
+
+
diff --git a/language/control-structures/switch.xml b/language/control-structures/switch.xml
new file mode 100644
index 000000000..d1e0c5ea6
--- /dev/null
+++ b/language/control-structures/switch.xml
@@ -0,0 +1,324 @@
+
+
+
+
+ switch
+
+
+ L'istruzione switch è simile a una serie di
+ istruzioni IF sulla stessa espressione. In molte occasioni, potrebbe essere
+ necessario confrontare la stessa variabile (o espressione) con molti
+ valori differenti, ed eseguire un pezzo di codice diverso a seconda
+ del valore a cui corrisponde. Questo è esattamente lo scopo
+ dell'istruzione switch.
+
+
+
+ A differenza di alcuni altri linguaggi, l'istruzione
+ continue
+ si applica a switch e agisce in modo simile a break. Se
+ c'è un switch all'interno di un ciclo e si desidera continuare alla prossima iterazione del
+ ciclo esterno, utilizzare continue 2.
+
+
+
+
+ switch/case effettua un
+ confronto debole.
+
+
+
+
+ Nell'esempio seguente, ogni blocco di codice è equivalente.
+ Uno usa una serie di istruzioni if e
+ elseif, e l'altro un'istruzione
+ switch. In entrambi i casi, l'output è lo stesso.
+
+ Struttura <literal>switch</literal>
+
+
+]]>
+
+
+
+
+ È importante capire come l'istruzione switch
+ viene eseguita per evitare errori. L'istruzione
+ switch esegue riga per riga
+ (in realtà, istruzione per istruzione). All'inizio, nessun codice viene
+ eseguito. Solo quando viene trovata un'istruzione case
+ la cui espressione si valuta a un valore che corrisponde al valore
+ dell'espressione switch, PHP inizia ad eseguire le
+ istruzioni. PHP continua ad eseguire le istruzioni fino alla fine
+ del blocco switch, o fino a quando non incontra
+ un'istruzione break. Se non viene scritta un'istruzione
+ break alla fine della lista di istruzioni di un case,
+ PHP continuerà ad eseguire le istruzioni del
+ case seguente. Ad esempio:
+
+
+
+]]>
+
+
+
+
+ Qui, se $i è uguale a 0, PHP eseguirebbe tutte le istruzioni echo!
+ Se $i è uguale a 1, PHP eseguirebbe le ultime due
+ istruzioni echo. Il comportamento atteso ('i è uguale a 2'
+ verrebbe visualizzato) si otterrebbe solo se $i è uguale a 2. Pertanto,
+ è importante non dimenticare le istruzioni break
+ (anche se in determinate circostanze si potrebbe intenzionalmente evitare
+ di fornirle).
+
+
+ In un'istruzione switch, la condizione viene
+ valutata una sola volta e il risultato viene confrontato con ogni
+ istruzione case. In un'istruzione elseif,
+ la condizione viene valutata nuovamente. Se la condizione è
+ più complessa di un semplice confronto e/o si trova in un ciclo intensivo,
+ un switch può essere più veloce.
+
+
+ La lista di istruzioni per un case può anche essere vuota, il che
+ passa semplicemente il controllo alla lista di istruzioni del case successivo.
+
+
+
+]]>
+
+
+
+
+ Un caso speciale è il case default. Questo case corrisponde
+ a tutto ciò che non è stato soddisfatto dagli altri case. Ad esempio:
+
+
+
+]]>
+
+
+
+
+ Più case default genereranno un errore
+ E_COMPILE_ERROR.
+
+
+
+
+ Tecnicamente il case default può essere elencato
+ in qualsiasi ordine. Verrà utilizzato solo se nessun altro case corrisponde.
+ Tuttavia, per convenzione è preferibile posizionarlo alla fine come
+ ultimo ramo.
+
+
+
+
+ Se nessun ramo case corrisponde e non c'è un ramo default,
+ nessun codice verrà eseguito, come se nessuna istruzione if fosse vera.
+
+
+ Un valore di case può essere dato come espressione. Tuttavia, quell'espressione verrà
+ valutata da sola e poi confrontata debolmente con il valore dello switch. Ciò significa
+ che non può essere utilizzata per valutazioni complesse del valore dello switch. Ad esempio:
+
+
+
+]]>
+
+
+
+
+ Per confronti più complessi, il valore &true; può essere utilizzato come valore dello switch.
+ Oppure, in alternativa, blocchi if-else al posto di switch.
+
+
+
+]]>
+
+
+
+
+ La sintassi alternativa per le strutture di controllo è supportata con
+ gli switch. Per maggiori informazioni, consultare Sintassi alternativa
+ per le strutture di controllo.
+
+
+
+]]>
+
+
+
+
+ È possibile usare un punto e virgola al posto dei due punti dopo un case come:
+
+
+
+]]>
+
+
+
+
+
+ &reftitle.seealso;
+
+
+ &match;
+
+
+
+
+
+