10 anni fa
Solo una nota sull'uso dell'istruzione continue per rinunciare al resto di un ciclo - assicurati di "non emettere l'istruzione continue dall'interno di un caso SWITCH - così facendo non continuerai il ciclo while, ma piuttosto l'istruzione switch stessa.
Anche se ad alcuni può sembrare ovvio, ci sono voluti un po' di test per me, quindi spero che questo aiuti qualcun altro.
5 anni fa
È strano che il manuale dica...
"A volte, se l'espressione while restituisce FALSE fin dall'inizio, le istruzioni nidificate" non verranno eseguite nemmeno una volta. "
Perché non può essere A VOLTE
Se si comporta in questo modo, allora è un bug, perché non deve SEMPRE eseguire le istruzioni nidificate nemmeno una volta se l'espressione WHILE restituisce FALSE fin dall'inizio.
Un altro modo per uscire dal ciclo while è usare l'istruzione BREAK .. vedilo nel manuale.
E se l'espressione restituisce NULL è uguale a FALSE
while (espressione vale NULL) ()
14 anni fa
Solo una nota per stuart: la ragione di questo comportamento è perché l'uso del costrutto while (value = each (array)) incrementa il contatore interno dell'array durante il ciclo. Pertanto, se si intende ripetere il ciclo, è necessario azzerare il contatore. per esempio:
$ uno = array ("10", "20", "30", "40");
$ due = array ("a", "b", "c", "d");
$ io = 0;
mentre ($ i< count($one)) {
resetta ($ due);
mentre ($ un = ciascuno ($ due)) (
echo $ a. "-". $ uno [$ i]. ",";
}
$i++;
a - 10, b - 10, c - 10, d - 10, a - 20, b - 20, c - 20, d - 20, a - 30, b - 30, c - 30, d - 30, a - 40, b - 40, c - 40, d - 40,
15 anni fa
Mentre può fare miracoli se hai bisogno di qualcosa per mettere in coda la scrittura su un file mentre qualcos'altro ha accesso ad esso.
Ecco il mio semplice esempio:
Scrittura funzione ($ dati, $ file, $ modalità_scrittura = "w") (
$ blocco = $ file. ".serratura";
// esegue la correzione della scrittura, per interrompere eventuali conflitti che potrebbero verificarsi
write_fix ($ blocco);
// crea un nuovo file di blocco dopo write_fix() per questa sessione di scrittura
toccare ($ blocco);
// scrivi sul tuo file
$ open = fopen ($ file, $ write_mode);
fwrite ($ aperto, $ dati);
fclose ($ aperto);
// uccidi il tuo lucchetto attuale
scollega ($ lock);
}
Funzione write_fix ($ lock_file) (
while (file_esiste ($ lock_file) (
// fai qualcosa qui dentro?
// forse dormi per qualche microsecondo
// per mantenere la stabilità, se questo sta per
// richiedere del tempo ??
}
}
?>
Questo metodo non è raccomandato per l'uso con programmi che avranno bisogno di alcuni secondi per scrivere su un file, poiché la funzione while consumerà molti cicli di processo. Tuttavia, questo metodo funziona ed è facile da implementare. Raggruppa anche le funzioni di scrittura in un'unica funzione facile da usare, semplificando la vita. :-)
17 anni fa
Alla fine del ciclo while (list / each) il puntatore dell'array sarà alla fine.
Ciò significa che il secondo ciclo while su quell'array verrà saltato!
Puoi rimettere il puntatore all'array con la funzione reset ($ myArray).
$ myArray = array ("aa", "bb", "cc", "dd");
resetta ($ myArray);
while (list ($ key, $ val) = each ($ myArray)) echo $ val;
?>
7 anni fa
Invece di questo uso;
$ arr = array ("arancione", "banana", "mela", "lampone");
$ io = 0;
mentre ($ i<
count
($arr
)) {
$ a = $ arr [$ i];
eco $ a. "\ n";
$i++;
}
// o
$ io = 0;
$ c = conteggio ($ arr);
mentre ($ i<
$c
) {
$ a = $ arr [$ i];
eco $ a. "\ n";
$i++;
}
?>
Questo potrebbe essere più efficiente;
while ($ a = $ arr [1 * $ i ++]) echo $ a. "\ n";
?>
16 anni fa
Ho fatto un test attraversando un array (array numerico semplice, ma lungo con tasti numerici). Il mio test ha avuto un ciclo per metodo e ha moltiplicato ogni elemento dell'array per 100 .. Questi erano i miei risultati:
******************************************************
30870 Attraversamento array di elementi
0.2373 seg dopo -> while (list ($ key, $ val) = ogni ($ array)) FINISCE
0.1916 seg dopo -> while (list ($ chiave,) = ogni ($ array)) FINISCE
0,1714 secondi dopo -> foreach ($ array AS $ chiave => $ valore) FINE
0.0255 seg later -> while ($ next = next ($ array)) FINISCE
0,1735 secondi dopo -> foreach ($ array AS $ valore) FINE
**************************************************************
foreach è più grasso di un po' (elenco - ciascuno), vero.
Tuttavia, un po' di tempo (successivo) è stato più veloce di prima.
Questi i codici vincenti:
$ array = $ salva;
test_time ("", 1);
foreach ($ array AS $ chiave => $ valore)
test_time ("foreach (\ $ array AS \ $ chiave => \ $ valore)");
$ array = $ salva;
test_time ("", 1);
resetta ($ array);
while ($ successivo = successivo ($ array))
($ chiave = chiave ($ array);
$ array [$ chiave] = $ array [$ chiave] * 100;
}
test_time ("while (\ $ next = next (\ $ array))");
*********************************************************
Il miglioramento sembra enorme, ma non è così drammatico nella pratica reale. I risultati sono stati vari... Ho un array bidimensionale molto lungo e ho visto non più di 2 secondi di differenza, ma su oltre 140 secondi di script. Nota però che perdi il controllo del valore della chiave $ (a meno che tu non abbia tasti numerici, che tendo a evitare), ma non è sempre necessario.
In genere mi attengo a foreach. Tuttavia, questa volta, ricevevo errori di dimensione della memoria consentita superata con Apache. Ricorda che foreach copia l'array originale, quindi questo ora crea due enormi array 2D in memoria e molto lavoro per Apache. Se ricevi questo errore, controlla i tuoi loop. Non utilizzare l'intero array su un foreach. Invece prendi le chiavi e accedi direttamente alle celle. Inoltre, prova a utilizzare unset e Referencing sugli enormi array.
Lavorare sull'array e sui loop è una soluzione molto migliore rispetto al salvataggio in tabelle temporanee e all'annullamento dell'impostazione (molto più lento).
14 anni fa
Lo speedtest è interessante. Ma il modo apparentemente più veloce contiene una trappola per i principianti che lo usano semplicemente perché è veloce e veloce è bello;)
Camminare attraverso un array con next() taglierà la prima voce, poiché questo è il modo in cui next() funziona;)
Se hai davvero bisogno di farlo in questo modo, assicurati che il tuo array contenga una voce vuota all'inizio. Un altro modo sarebbe usare
while ($ questo = corrente ($ array)) (
fai_qualcosa ($ questo);
successivo ($ array);
}
?>
C'è sicuramente un impatto sulla velocità, ma non l'ho testato. Consiglierei di attenersi ai metodi convenzionali perché current (), next () in while loop è troppo soggetto a errori per me.
4 anni fa
Un modo fantastico per continuare a valutare qualcosa finché non fallisce un test.
mentre (vero) (
if ("prova") ( // è vera la condizione iniziale
// fai qualcosa che cambi anche la condizione iniziale
) else (// condizione non riuscita
rottura; // lascia il ciclo
}
}
?>
4 anni fa
Semplice programma di pattern piramidali che utilizza il ciclo while
$ io = 1;
mentre ($ i<=
5
)
{
$j = 1;
mentre ($ j<=
$i
)
{
echo "* & nbsp & nbsp";
$j++;
}
eco "
"
;
$i++;
}
?>
// o in alternativa puoi usare:
$ io = 1;
mentre ($ i<=
5
):
$j = 1;
mentre ($ j<=
$i
):
echo "* & nbsp & nbsp";
$j++;
alla fine;
Eco "
"
;
$i++;
alla fine;
?>
11 anni fa
A causa del fatto che php interpreta solo gli elementi necessari per ottenere un risultato, ho trovato conveniente concatenare diverse query sql in un'unica istruzione:
$ q1 = "qualche query su un insieme di tabelle";
$ q2 = "query simile su un altro set di tabelle";
if (($ r1 = mysql_query ($ q1)) && ($ r2 = mysql_query ($ q2))) (
Mentre (($ riga = mysql_fetch_assoc ($ r1)) || ($ riga = mysql_fetch_assoc ($ r2))) (
/ * fai qualcosa con $ row proveniente da $ r1 e $ r2 * /
}
}
?>
3 anni fa
// prova Mentre Vs per php 5.6.17
$ t1 = microtempo (vero);
$ un = 0;
mentre ($ a ++<=
1000000000
);
$ t2 = microtempo (vero);
$ x1 = $ t2 - $ t1;
echo PHP_EOL, "> mentre ($ a ++<= 100000000); : "
, $ x1, "s", PHP_EOL;
$ t3 = microtempo (vero);
per ($ a = 0; $ a<=
1000000000
;
$a
++);
$ t4 = microtempo (vero);
$ x2 = $ t4 - $ t3;
echo PHP_EOL, "> per ($ a = 0; $ a<= 100000000;$a++); : "
, $ x2, "s", PHP_EOL;
$ t5 = microtempo (vero);
$ un = 0; per (; $ a ++<=
1000000000
;);
$ t6 = microtempo (vero);
$ x3 = $ t6 - $ t5;
echo PHP_EOL, "> $ a = 0; for (; $ a ++<= 100000000;); : "
, $ x3, "s", PHP_EOL;
//> while ($ a ++<= 100000000); = 18.509671926498s
//> per ($ a = 0; $ a<= 100000000;$a++); = 25.450572013855s
//> $ a = 0; per (; $ a ++<= 100000000;); = 22.614907979965s
// ===================
//> while ($ a ++! = 10000000); : 18.204656839371s
//> for ($ a = 0; $ a! = 10000000; $ a ++); : 25.025605201721s
//> $ a = 0; for (; $ a ++! = 10000000;); : 22.340576887131s
// ===================
//> while ($ a ++< 100000000); : 18.383454084396s
//> per ($ a = 0; $ a< 100000000;$a++); : 25.290743112564s
//> $ a = 0; per (; $ a ++< 100000000;); : 23.28609919548s
?>
16 anni fa
Questo è un modo semplice per tutti voi creatori di calcolatrici per fargli fare i fattoriali. Il codice è questo:
$ c = ($ a - 1);
$ d = $ un;
mentre ($ c> = 1)
{
$ un = ($ un * $ c);
$ c-;
}
print ("$ d! = $ a");
?>
$ a cambia, e anche c, quindi dobbiamo creare una nuova variabile, $ d, per l'istruzione end.
Il ciclo foreach di PHP può essere utilizzato in questo modo:
foreach ($ nome_array come valore $) (// codice da eseguire)
foreach ($ nome_array as $ chiave => $ valore) (// // codice da eseguire)
Esempio di utilizzo di un ciclo foreach con un array numerico
In questo esempio, creeremo un array di cinque elementi con valori numerici. Il ciclo foreach di PHP verrà quindi utilizzato per scorrere questo array. All'interno del ciclo foreach, abbiamo usato echo per stampare i valori dell'array:
Visualizza demo e codice
Esempio con chiavi e valori di array
Questo esempio descrive un altro modo per utilizzare il ciclo foreach di PHP. Per questo, abbiamo creato un array associativo di tre elementi. Include i nomi dei dipendenti ( come chiavi) e l'importo del salario ( come valori):
Visualizza demo e codice
Un esempio di modifica del valore di un elemento dell'array in un ciclo foreach
Puoi anche utilizzare l'array PHP foreach per modificare i valori degli elementi dell'array. Per fare ciò, usa "&" prima di "$" per il valore della variabile. Per esempio:
& $ valore_di_elemento
Il valore verrà modificato. Per renderlo più chiaro, si consideri il seguente esempio.
In questo esempio, abbiamo creato un array numerico di cinque elementi. Successivamente, abbiamo utilizzato un ciclo foreach per visualizzare i valori degli elementi.
Quindi abbiamo creato un altro ciclo foreach in cui "&" viene aggiunto prima di $ value_of_element. All'interno delle parentesi graffe, assegniamo nuovi valori agli elementi dell'array.
Per vedere la differenza prima e dopo l'assegnazione di nuovi valori, l'array viene visualizzato utilizzando la funzione print_r().
Visualizza demo e codice
A cosa serve il ciclo PHP foreach?
Il ciclo foreach di PHP viene utilizzato per lavorare con un array. Itera su ciascuno dei suoi elementi.
Puoi anche usare un ciclo for per lavorare con gli array. Ad esempio, utilizzando la proprietà length per ottenere la lunghezza di un array e quindi applicarla come operatore max. Ma foreach lo rende più semplice perché è progettato per funzionare con gli array.
Se stai lavorando con MySQL, questo ciclo è ancora più adatto a questo. Ad esempio, puoi selezionare più righe da una tabella di database e passarle a un array. Successivamente, utilizzando un ciclo foreach, iterare su tutti gli elementi dell'array ed eseguire alcune azioni.
Nota che puoi usare un ciclo foreach con un array o solo un oggetto.
Utilizzo di un ciclo foreach
Esistono due modi per utilizzare il ciclo foreach PHP in PHP. Entrambi sono descritti di seguito.
- La sintassi per il primo metodo di utilizzo è:
foreach ($ nome_array come $ valore) (echo $ valore)
In questo caso, è necessario specificare il nome dell'array e quindi il valore della variabile $.
Per ogni iterazione, il valore dell'elemento corrente viene assegnato alla variabile $ value. Al completamento dell'iterazione, alla variabile viene assegnato il valore dell'elemento successivo. E così via finché non vengono enumerati tutti gli elementi dell'array.
- La sintassi del secondo metodo ( PHP foreach come valore chiave):
Questo è adatto per array associativi che utilizzano coppie chiave/valore.
Durante ogni iterazione, il valore dell'elemento corrente sarà assegnato alla variabile $ value_of_element. Inoltre, la chiave dell'elemento è assegnata alla variabile $ key_of_element.
Se stai lavorando con array numerici, puoi usare il primo metodo, che non richiede chiavi di elemento.
Questa pubblicazione è una traduzione dell'articolo " PHP foreach loop 2 modi per usarlo"Preparato dal team di progetto amichevole
La nota: viene attivata la versione adattiva del sito, che si adatta automaticamente alle piccole dimensioni del tuo browser e nasconde alcuni dettagli del sito per la leggibilità. Buona visione!
Ciao cari lettori e abbonati abituali! È ora di continuare la serie di articoli su PHP e oggi impareremo una cosa così basilare e allo stesso tempo molto importante, come i loop. Qual è la prima cosa che devi sapere sui loop? E il fatto che siano usati ovunque e ovunque, e modelli Joomla, VirtueMart, Wordpress, OpenCart e qualsiasi altro CMS non fa eccezione.
Che cos'è un ciclo? CicloÈ una ripetizione multipla dello stesso pezzo di codice. Quante ripetizioni bisogna fare dipende dal contacicli, che noi stessi creiamo e possiamo gestire. Questo è molto conveniente, ad esempio, quando dobbiamo disegnare prodotti nella categoria di un negozio online, visualizzare post di blog, visualizzare commenti su un articolo o un prodotto, anche tutti i menu in CMS (motori del sito) sono realizzati utilizzando i loop. In generale, i loop sono usati molto spesso.
Ma prima di passare ai loop stessi, devi prima scherzare con cose come gli operatori incremento e decremento.
L'operatore ++ (incremento) aumenta il valore di una variabile di uno, mentre l'operatore - (decremento) diminuisce il valore di una variabile di uno. Sono molto comodi da usare nei loop come contatore, e nella programmazione in generale. Ci sono anche incremento/decremento PRE e incremento/decremento POST:
PRE incrementa / decrementa ++ $ a Incrementa $ a di uno e restituisce il valore di $ a. - $ a Diminuisce $ a di uno e restituisce il valore di $ a. POST incremento/decremento $ a ++ Restituisce il valore di $ a e quindi incrementa $ a di uno. $ a-- Restituisce il valore di $ a e quindi decrementa $ a di uno.
Per esempio:
$ a = 1; echo "Stampa numero:". $ a++; // Stampa numero: 1 echo "Stampa numero:". $ un; // Emissione di un numero: 2 echo "Emissione di un numero: $ a"; $ un + = 1; // come nella prima riga$ a = 1; echo "Stampa numero:". ++ $ un; // Stampa numero: 2 echo "Stampa numero:". $ un; // Visualizza il numero: 2 $ a + = 1; echo "Stampa numero: $ a"; // lo stesso della prima riga di questo blocco
Per il ciclo
for (parte A; parte B; parte C) (// Qualsiasi codice, quante righe vuoi;)Il ciclo for è composto da 3 parti e dal corpo stesso. parte A fa solo quello che dice, di regola, nel 90% dei casi, viene creato un contatore di loop lì. parte B- questo, grosso modo, ci è già familiare Se, ovvero verificando il vero (vero?). Se la condizione è vera, cioè vero, quindi PHP entra nel ciclo e continua a eseguirlo. Parte C- lo stesso della parte A, di norma nella parte C eseguiamo una sorta di conversione con un contatore. Per esempio:
";) echo" GUARDA e prosegui nel codice ... ";?>
Ora sull'algoritmo del ciclo for. Prima di tutto, quando lo vede per, PHP va nella parte A e lo esegue una volta (vedi immagine sotto). PHP quindi va a B e controlla se c'è vero o falso. Se vero, esegue il corpo del ciclo e solo allora passa alla parte C. Dopodiché PHP torna alla parte B e verifica se è ancora vero o meno. In caso negativo, il ciclo termina, in caso affermativo continua fino a quando la parte B non è falsa.
Il risultato dell'esempio precedente:
Mentre il ciclo
while (parte B) (// Qualsiasi codice, quante righe vuoi;)Come puoi vedere, non c'è la parte A e la parte C, rimane solo la condizione dal ciclo for, cioè la parte B. Se dobbiamo usare un contatore, allora dobbiamo metterlo all'interno del ciclo while, tra il resto del codice, questa sarà la parte C. il contatore è necessario prima dell'inizio della costruzione del while:
parte A; while (parte B) (// Qualsiasi codice, quante righe vuoi; Parte C;)
Trasformiamo il precedente ciclo for in un ciclo while:
"; $ i ++;) echo" GUARDA e prosegui nel codice ... ";?>
Il risultato sarà esattamente lo stesso. Cosa usare: un ciclo for o un ciclo while è una questione di gusti, guarda come è più conveniente e logico per te, non c'è differenza.
Fai ... durante il ciclo
Meno comune di tutti i tipi di cicli. È essenzialmente un tempo invertito. Il suo trucco è che PHP almeno una volta (il primo), ma andrà sicuramente nel corpo del ciclo do ... while, perché in questo ciclo la condizione alla fine:
parte A; do (// Qualsiasi codice, quante righe vuoi; Parte C;) while (Parte B);
"; $ i ++;) while ($ i< 8); echo "ВЫШЛИ ИЗ ЦИКЛА и пошли дальше по коду..."; ?>
È importante capire che non ci sono parti obbligatorie in tutti e tre i tipi di cicli.
Un esempio di un ciclo for senza la parte A e la parte C:
Per (; $ i> 8;) (// il tuo codice)
Un esempio di un ciclo for senza tutte e tre le parti:
For (;;) (// classico ciclo infinito)
Cioè, tutti i punti e virgola rimangono ancora nel ciclo for, questa è la sintassi!
Loop infiniti
Un ciclo infinito è un errore dello sviluppatore in cui la pagina non sarà mai in grado di caricare fino alla fine, poiché la condizione del ciclo (parte B) sarà sempre vera. Per esempio:
"; $ i ++;) while ($ i! = 0); echo" ESCI DAL CICLO e prosegui nel codice ... ";?>
Risultato:
Questo ho mostrato solo una parte, perché tutto non si adatta allo schermo. È così che il tuo browser e il server del tuo sito si tormenteranno all'infinito fino a quando il browser si blocca dopo 30 secondi.Questo perché nell'esempio sopra, la variabile $ i non sarà mai uguale a zero, è inizialmente uguale a 1 ed è in costante aumento.
Cioè, lo sviluppatore era disattento quando ha inventato una tale condizione.
Controllo del ciclo
La dichiarazione di rottura. Ci sono situazioni in cui non abbiamo bisogno del loop per riprodurre tutte le iterazioni (ripetizioni). Ad esempio, in un determinato momento vogliamo interromperlo e continuare l'esecuzione di seguito nel codice:
"; if ($ i === 5) break; // esce dal ciclo se $ i è 5 $ i ++;) echo" Posso contare solo fino a 5 :( ";?>
Risultato:
Nell'esempio sopra, non appena siamo arrivati a cinque, PHP è uscito dal ciclo, altrimenti conterebbe fino a 7.
La dichiarazione continua interrompe anche l'esecuzione del ciclo, ma a differenza di break, continue non esce dal ciclo, ma riporta l'interprete PHP alla condizione (alla parte B). Esempio:
";) echo" Ti sei perso qualcosa? ";?>
Risultato:
Abbiamo appena saltato il 5 perché PHP non ha avuto l'eco.
Un ciclo può essere annidato all'interno di un ciclo. In questo caso, le istruzioni continue e break coprono solo un ciclo, quello in cui si trovano. Cioè, in altre parole, vengono lanciati di un livello e non attraverso tutti. Esempio:
Ma noi stessi possiamo scegliere quanti livelli saltare:
"; $ i ++; $ i = 1; $ k = 1; mentre ($ k< 8) {
echo "Итерация $k номер ". $k . "
"; if ($ k === 5) break 2; $ k ++;))?>
Risultato:
Naturalmente, in questo caso, non possiamo inserire un numero maggiore dei nostri cicli annidati.
Per ogni ciclo
Il più recente, ma più importante, è il ciclo foreach. Usato da soltanto iterare su e oggetti (è troppo presto per impararli). Sintassi di esempio:
"; } ?>
Risultato:
Era una costruzione foreach corta, ma ha anche una versione estesa, che, oltre ai valori delle celle dell'array, mostra anche i nomi delle celle (chiavi):
$ valore) (echo "Nella sezione ". $ chiave." c'è un articolo intitolato: ". $ valore."
";
}
?>
Risultato:
Attiro la vostra attenzione sul fatto che possiamo chiamare le variabili come vogliamo, anche $ key e $ value, anche $ xxx e $ yyy.
Se un array, allora usiamo solo il ciclo foreach e nessun altro. Questo ciclo è utilizzato in tutto VirtueMart, e in effetti ovunque.
Spesso è conveniente poter terminare il ciclo prima del previsto quando si verificano determinate condizioni. Questa opportunità è fornita dall'istruzione break. Funziona con costrutti come while, do while, for, foreach o switch.
L'istruzione break può accettare un argomento numerico facoltativo che indica quante strutture nidificate terminare. Il valore predefinito per un argomento numerico è 1, che termina l'esecuzione del ciclo corrente. Se un'istruzione switch viene utilizzata in un ciclo, break/break 1 esce solo dall'istruzione switch.
\ n "; break 1; / * Esce solo dall'istruzione switch. * / case 10: echo" Iterazione 10; in partenza
\ n "; break 2; / * Esce dalla costruzione switch e dal ciclo while. * /)) // altro esempio per ($ bar1 = -4; $ bar1< 7; $bar1++) {
// проверка деления на ноль
if ($bar1 == 0) {
echo "Выполнение остановлено: деление на ноль невозможно.";
break;
}
echo "50/$bar1 = ",50/$bar1,"
";
}
?>
Naturalmente, a volte preferiresti semplicemente saltare una delle iterazioni del ciclo piuttosto che terminare completamente il ciclo, nel qual caso ciò viene fatto usando l'istruzione continue.
Continua
Per interrompere l'elaborazione del blocco di codice corrente nel corpo del ciclo e passare all'iterazione successiva, puoi utilizzare l'istruzione continue. Differisce dall'istruzione break in quanto non termina il ciclo, ma passa semplicemente all'iterazione successiva.
L'istruzione continue, come break, può accettare un argomento numerico facoltativo, che indica quanti livelli di cicli annidati verrà ignorato dal resto dell'iterazione. Il valore predefinito per un argomento numerico è 1, che ignora solo il resto del ciclo corrente.
"; continue;) echo" 50 / $ bar1 = ", 50 / $ bar1"
";
}
?>
Nota: durante il ciclo, il valore zero della variabile contatore $ è stato saltato, ma il ciclo è continuato dal valore successivo.
vai a
goto è un operatore di salto incondizionato. Viene utilizzato per passare a un'altra sezione del codice del programma. Il punto in cui devi andare nel programma è indicato da un'etichetta (identificatore semplice) seguita da due punti. Per la transizione, l'etichetta desiderata viene posizionata dopo l'istruzione goto.
Un semplice esempio di utilizzo dell'istruzione goto:
L'istruzione goto ha alcune limitazioni al suo utilizzo. L'etichetta di destinazione deve trovarsi nello stesso file e nello stesso contesto, il che significa che non puoi uscire dai limiti di una funzione o di un metodo, né puoi entrare in uno di essi. Inoltre, non puoi entrare in alcun ciclo o istruzione switch. Ma può essere usato per uscire da questi costrutti (da cicli e istruzioni switch). Solitamente viene utilizzata un'istruzione goto al posto delle interruzioni multilivello.
";) echo" dopo il ciclo - fino al segno "; // l'istruzione non verrà eseguita end: echo" Dopo il segno ";?>
