Scopri tutto su Golang per loop codificando diversi esempi utili.
Recentemente linguaggi di programmazione come Rust, Golang e TypeScript sono diventati molto popolari tra gli sviluppatori. Se sei interessato allo sviluppo back-end e DevOps, dovresti considerare che l’apprendimento di Golang è un’opzione eccellente!
Se sei un principiante che impara i fondamenti di un linguaggio di programmazione, i costrutti di loop sono uno dei primi concetti che dovresti capire.
Golang fornisce solo il costrutto del ciclo for. E impareremo i cicli for e anche come emulare altri cicli usando il ciclo for.
Cominciamo!
Sommario:
Sintassi di Golang For Loop
In Golang, puoi creare un ciclo for usando la seguente sintassi:
for initialization; condition; update {
// do something
}
Qui,
- inizializzazione denota l’inizializzazione della variabile di ciclo.
- condition è la condizione del ciclo che determina l’esecuzione del corpo del ciclo. Finché la condizione del ciclo restituisce true, le istruzioni nel corpo del ciclo vengono eseguite. E quando la condizione diventa falsa, il controllo esce dal ciclo.
- update denota l’aggiornamento della variabile di ciclo, solitamente un incremento o un decremento.
💡 Nota come questo è simile al ciclo C for solo senza le parentesi.
Ecco il flusso di controllo in Golang per i loop:
È ora di codificare alcuni esempi! ⏰ Per codificare insieme, puoi utilizzare un’installazione locale di Golang o eseguire gli esempi su Go Playground.
Golang For Loop Esempi
Usiamo la sintassi che abbiamo appena imparato per scrivere il nostro primo ciclo for. Ecco un semplice ciclo for che stampa i numeri da 1 a 5 in passi di uno.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Inizializziamo la variabile di ciclo i a 1, impostiamo la condizione a i <= 5 e incrementiamo la variabile di ciclo di uno dopo ogni iterazione. Ed ecco l'output:
//Output For loop: 1 2 3 4 5
Scriviamo un altro ciclo for. Questo ciclo inizia da 5 e conta fino a 1; va avanti fino a quando la variabile del ciclo è maggiore o uguale a 1. Quindi decrementiamo la variabile del ciclo di uno dopo ogni iterazione.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := num; i >= 1; i-- {
fmt.Println(i)
}
}
E otteniamo l’output atteso:
//Output For loop: 5 4 3 2 1
Qual è l’ambito della variabile di ciclo?
L’ambito della variabile di ciclo è limitato al blocco del ciclo for e non è accessibile al di fuori del ciclo.
Per verificarlo, proviamo ad accedere al valore della variabile di ciclo i al di fuori del ciclo:
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
fmt.Println(i)
}
Come previsto, ci imbattiamo in un errore che afferma che i è un undefined (e il suo ambito è ristretto al ciclo for):
// Output ./prog.go:11:14: undefined: i
Infinite For Loop in Golang
Possiamo avere cicli for infiniti in Go? Sì, certo che possiamo!
Se osservi il flusso di controllo del ciclo for:
- Il corpo del ciclo continuerà a essere eseguito fintanto che la condizione restituisce true.
- Quando la condizione diventa falsa, il controllo esce dal ciclo.
- Quindi se la condizione non diventa mai falsa (o è sempre vera), abbiamo un ciclo infinito.
Ma puoi anche usare il ciclo for senza l’inizializzazione, la condizione e l’aggiornamento, senza incorrere in errori di sintassi. Quindi, se puoi far funzionare il ciclo all’infinito anche usando un costrutto del ciclo for come questo:
package main
import "fmt"
func main() {
for {
fmt.Println("running...")
}
}
//Output running... running... running... running... running... //and it goes on forever!
In questo esempio, impostiamo la variabile num su 5. E la condizione del ciclo è num >= 5. Quindi il ciclo viene eseguito finché num è maggiore o uguale a zero.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Poiché il valore di num non cambia mai, la condizione restituisce sempre true e il ciclo viene eseguito all’infinito!
//Output 5 5 5 5 5 5 //and it goes on forever!
Tutti i Golang hanno solo il costrutto del ciclo for, possiamo provare ad emulare i cicli while e do-while usando i cicli for. Quindi impariamo come farlo!
Emulazione di While Loop utilizzando For Loop
Il ciclo while generalmente assume la seguente forma:
// initialize looping var
while (condition){
// do something
// update looping var
}
Se ricordi, nel primo ciclo for infinito abbiamo scritto: abbiamo usato il seguente ciclo for, senza l’inizializzazione, la condizione e l’aggiornamento.
for {
// the simplest infinite loop
}
Quindi possiamo modificare il ciclo for per contenere solo la condizione (nella seguente forma) per emulare il ciclo while:
//initialize looping var
for condition {
// do something
// update looping var
}
Ecco l’equivalente del ciclo while del primo ciclo for che abbiamo scritto:
package main
import "fmt"
func main() {
fmt.Println("Emulating while loop")
num := 5
for num > 0 {
fmt.Println(num)
num--
}
}
//Output Emulating while loop 5 4 3 2 1
Emulazione di Do-While Loop utilizzando For Loop
Se hai codificato in un linguaggio come C, sai che il costrutto del ciclo do-while assume la seguente forma:
// initialize looping var
do {
//something
// update looping var
} while(condition);
La differenza fondamentale tra il ciclo while e do while è che il ciclo while controlla la condizione all’ingresso nel ciclo. Il ciclo do-while, invece, controlla la condizione all’uscita dal ciclo.
Quindi, in un ciclo while, se la condizione restituisce false, il corpo del ciclo non viene mai eseguito. Tuttavia, in un ciclo do-while, il corpo del ciclo viene eseguito anche se la condizione restituisce false.
Utilizzando queste informazioni, possiamo emulare il comportamento di un ciclo do-while:
- Scrivi un ciclo for infinito
- Utilizzare un’istruzione condizionale if con la condizione corretta per uscire dal ciclo
Supponi di voler scrivere un ciclo do-while in cui la condizione per l’esecuzione del corpo del ciclo è num <0. Quindi puoi scrivere un ciclo for e uscire dal ciclo se num >= 0.
package main
import "fmt"
func main() {
fmt.Println("Emulating do-while loop")
num := 5
for {
fmt.Println("loop runs...")
if num >= 0 {
break
}
}
}
💡 Nota che l’esecuzione del ciclo se num < 0 e l'uscita dal ciclo se num >= 0 sono condizioni equivalenti.
Sebbene la condizione num > 0 sia inizialmente falsa (num è 5), il corpo del ciclo viene eseguito una volta, emulando un ciclo do-while.
//Output Emulating do-while loop loop runs...
Looping attraverso gli array utilizzando For Loop
Quando si esegue il ciclo degli array in Golang utilizzando un ciclo for e un intervallo, è possibile accedere sia agli indici che agli elementi. Funziona in modo simile alla funzione enumerate in Python.
Qui creiamo numArray, un array di numeri interi. E passalo in rassegna usando un ciclo for:
package main
import "fmt"
func main() {
fmt.Println("Looping through an array")
numArray := []int{3, 7, 0, 10, 8, 9}
for idx, num := range numArray {
fmt.Println("At index", idx, ": ", num)
}
}
Come visto, siamo in grado di accedere contemporaneamente sia all’indice che all’elemento in ciascun indice:
//Output Looping through an array At index 0 : 3 At index 1 : 7 At index 2 : 0 At index 3 : 10 At index 4 : 8 At index 5 : 9
Utilizzo del differimento in Golang For Loop
In Golang, puoi utilizzare la parola chiave defer per rinviare le chiamate di funzione.
Anche se utilizzato in applicazioni come la pulizia delle risorse e la gestione degli errori, può essere utile capire come utilizzare il rinvio all’interno di un ciclo for. Vediamo cosa succede quando usiamo defer all’interno del ciclo for per rinviare le chiamate alla funzione Println().
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
defer fmt.Println(i)
}
}
💬 Quando una chiamata di funzione viene rinviata, la chiamata di funzione viene inserita nello stack ed eseguita in ordine LIFO. Questa esecuzione avviene solo dopo la restituzione della funzione che circonda l’istruzione defer.
Quindi fmt.Println(5) viene eseguito per primo e fmt.Println(1) viene eseguito per ultimo:
//Output For loop: 5 4 3 2 1
Conclusione
Ecco un riepilogo di ciò che hai imparato in questo tutorial:
- In Golang, puoi creare cicli for con la sintassi: for initialization; condizione; update { //corpo del ciclo}.
- Il flusso di controllo del ciclo for è abbastanza semplice. La variabile di ciclo viene inizializzata una volta, la condizione di ricerca determina se eseguire o meno il corpo del ciclo e l’aggiornamento si riferisce all’aggiornamento della variabile di ciclo dopo ogni iterazione.
- L’ambito della variabile di ciclo è limitato al corpo del ciclo e non è accessibile al di fuori del ciclo.
- Sebbene Golang fornisca solo il costrutto del ciclo for, puoi emulare i comportamenti del ciclo while e do-while usando i cicli for.
- Alcune altre applicazioni del ciclo for includono il ciclo degli array e il rinvio delle chiamate di funzione all’interno del corpo del ciclo for.
Successivamente, scopri come utilizzare i cicli for in Python. Buon apprendimento!🎉