1 Panoramica delle istruzioni di loop

Nel linguaggio Go, le istruzioni di loop ci permettono di eseguire un blocco di codice più volte. Quando è necessario eseguire determinate operazioni ripetutamente, le istruzioni di loop diventano molto utili. Ad esempio, potresti voler iterare attraverso ogni elemento in un array o ripetere un'operazione fino a quando non viene soddisfatta una condizione specifica. In Go, le istruzioni di loop sono principalmente implementate utilizzando la parola chiave for, che è l'unica istruzione di loop nel linguaggio Go. Il corretto utilizzo delle istruzioni di loop è cruciale per scrivere codice efficiente e manutenibile.

2 Fondamenti del loop for

2.1 Struttura del loop for

Il loop for nel linguaggio Go è composto da tre parti:

  1. Istruzione di inizializzazione: eseguita prima della prima iterazione, di solito utilizzata per dichiarare un contatore di loop.
  2. Espressione di condizione: valutata prima di ogni iterazione. Se la condizione è true, il corpo del loop viene eseguito.
  3. Istruzione post: eseguita dopo il blocco di codice di ogni iterazione, di solito utilizzata per aggiornare il contatore del loop.

La sintassi del loop for è la seguente:

for istruzione di inizializzazione; espressione di condizione; istruzione post {
    // codice del corpo del loop
}

2.2 Esempio semplice di loop for

Capiremo il processo di esecuzione del loop for attraverso un semplice esempio:

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Println("Il valore di i è:", i)
    }
}

In questo esempio, la variabile i viene inizializzata a 0. Il loop for verifica se la condizione i < 5 è vera. Se la condizione è vera, viene eseguito il corpo del loop e viene stampato il valore di i. Dopo aver eseguito il corpo del loop, il valore di i viene aggiornato tramite i++ (operazione di incremento), e quindi il loop riesamina la condizione fino a quando il valore di i raggiunge 5, momento in cui la condizione diventa falsa e il loop for termina.

2.3 Altri esempi di loop for

Il loop for nel linguaggio Go è molto flessibile e può essere scritto in varie forme per gestire diverse situazioni.

2.3.1 Loop infinito

In Go, puoi omettere l'istruzione di inizializzazione, l'espressione di condizione e l'istruzione post del loop for, creando un loop infinito che verrà eseguito fino a quando non viene terminato da un'istruzione break o da un valore di ritorno da una funzione.

for {
    // Codice all'interno di un loop infinito
    if someCondition {
        break // Esci dal loop quando viene soddisfatta una certa condizione
    }
}

2.3.2 Loop con solo condizione

In Go, puoi anche utilizzare un loop for che contiene solo una condizione, simile a un loop while in altri linguaggi di programmazione.

n := 0
for n < 5 {
    fmt.Println(n)
    n++
}

Il codice sopra stamperà 0 a 4, e il loop terminerà quando n raggiunge 5.

2.3.3 Iterare attraverso un array o una slice

In Go, la parola chiave range viene utilizzata per semplificare l'iterazione attraverso ciascun elemento di un array o di una slice.

items := []int{1, 2, 3, 4, 5}
for index, value := range items {
    fmt.Printf("Indice: %d, Valore: %d\n", index, value)
}

Il codice sopra stamperà l'indice e il valore di ciascun elemento. Se hai solo bisogno del valore degli elementi, puoi utilizzare _ per ignorare l'indice.

for _, value := range items {
    fmt.Printf("Valore: %d\n", value)
}

Nota: L'uso di array sarà spiegato dettagliatamente nei capitoli successivi. Se non comprendi questa parte, va bene purché tu capisca che il loop for può essere utilizzato in questo modo.

2.3.4 Ciclo attraverso le mappe

Quando si itera attraverso una mappa, la combinazione di ciclo for ed espressione range è molto potente. Questo ti consente di ottenere ogni coppia chiave-valore della mappa.

colori := map[string]string{"rosso": "#ff000", "verde": "#00ff00", "blu": "#000ff"}
for chiave, valore := range colori {
    fmt.Printf("Chiave: %s, Valore: %s\n", chiave, valore)
}

In questo esempio, stampiamo tutte le chiavi e i loro valori corrispondenti nella mappa colori. Similmente all'iterazione attraverso le slices, se hai bisogno solo della chiave o del valore, puoi scegliere di ignorare l'altro.

Nota: L'uso delle mappe sarà spiegato dettagliatamente nei capitoli successivi. Se non comprendi questa parte, va bene purché tu comprenda che il ciclo for può essere utilizzato in questo modo.

3 Controllo del flusso dei cicli

3.1 Utilizzare break per terminare un ciclo

A volte abbiamo bisogno di uscire dal ciclo prematuramente quando viene soddisfatta una specifica condizione e, in tali casi, può essere utilizzato lo statement break. Di seguito è mostrato un esempio di utilizzo di break per uscire da un ciclo:

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            break // Esci dal ciclo quando i è uguale a 5
        }
        fmt.Println("Il valore di i è:", i)
    }
    // L'output conterrà solo valori da 0 a 4
}

3.2 Utilizzare continue per saltare le iterazioni

In certe situazioni, potremmo voler saltare l'iterazione corrente e procedere con la successiva iterazione nel ciclo. Questo può essere ottenuto utilizzando lo statement continue. Ecco un esempio:

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i%2 != 0 {
            continue // Salta questa iterazione se i è dispari
        }
        fmt.Println("Numero pari:", i)
    }
}