Eseguire cicli sui dati con le espressioni for

Completato

Un altro flusso di controllo comune è il ciclo. Go usa un solo costrutto di ciclo, ovvero il ciclo for, ma è possibile rappresentare i cicli in più modi. In questa parte verranno fornite informazioni sui modelli di ciclo supportati da Go.

Sintassi di base per il ciclo for

Come le istruzioni if e le istruzioni switch, le espressioni di ciclo for non richiedono le parentesi, ma le parentesi graffe sono obbligatorie.

I punti e virgola (;) separano i tre componenti dei cicli for:

• Un'istruzione iniziale eseguita prima della prima iterazione (facoltativa).
• Un'espressione della condizione valutata prima di ogni iterazione. Il ciclo si interrompe quando questa condizione è false.
• Un'istruzione finale eseguita alla fine di ogni iterazione (facoltativa).

Come si può notare, il ciclo for in Go è simile al ciclo for in linguaggi di programmazione come C, Java e C#.

Nella sua forma più semplice, un ciclo for in Go ha un aspetto simile al seguente:

func main() {
    sum := 0
    for i := 1; i <= 100; i++ {
        sum += i
    }
    fmt.Println("sum of 1..100 is", sum)
}

Di seguito vengono presentati altri modi per scrivere i cicli in Go.

Istruzioni iniziali e istruzioni finali vuote

In alcuni linguaggi di programmazione si usa la parola chiave while per scrivere modelli di ciclo in cui è necessaria solo l'espressione della condizione. Go non include la parola chiave while, È tuttavia possibile usare in alternativa un ciclo for e sfruttare il fatto che Go rende facoltative le istruzioni iniziali e finali.

Usare il frammento di codice seguente per confermare che è possibile usare il ciclo for senza istruzioni iniziali e finali.

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    var num int64
    rand.Seed(time.Now().Unix())
    for num != 5 {
        num = rand.Int63n(15)
        fmt.Println(num)
    }
}

A condizione che la variabile num contenga un valore diverso da 5, il programma stampa un numero casuale.

Cicli infiniti e istruzioni break

Un altro modello di ciclo che è possibile scrivere in Go è il ciclo infinito. In questo caso, non si scrive un'espressione di condizione oppure un'istruzione iniziale o finale, ma si scrive la logica per uscire dal ciclo, che in caso contrario sarebbe infinito. Per impostare la logica per l'uscita da un ciclo, usare la parola chiave break.

Per scrivere un ciclo infinito corretto, aggiungere parantesi graffe dopo la parola chiave for, come indicato di seguito:

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    var num int32
    sec := time.Now().Unix()
    rand.Seed(sec)

    for {
        fmt.Print("Writing inside the loop...")
        if num = rand.Int31n(10); num == 5 {
            fmt.Println("finish!")
            break
        }
        fmt.Println(num)
    }
}

Ogni volta che si esegue questo codice, si ottiene un output diverso.

Istruzioni continue

In Go è possibile usare la parola chiave continue per saltare l'iterazione corrente di un ciclo. È possibile usare questa parola chiave, ad esempio, per eseguire una convalida prima che il ciclo continui. In alternativa, è possibile usarla quando si scrive un ciclo infinito ed è necessario attendere che una risorsa diventi disponibile.

Questo esempio usa la parola chiave continue:

package main

import "fmt"

func main() {
    sum := 0
    for num := 1; num <= 100; num++ {
        if num%5 == 0 {
            continue
        }
        sum += num
    }
    fmt.Println("The sum of 1 to 100, but excluding numbers divisible by 5, is", sum)
}

Questo esempio include un ciclo for che esegue l'iterazione da 1 a 100, aggiungendo il numero corrente alla somma in ogni iterazione. Ogni numero divisibile per 5 viene saltato nell'iterazione corrente del ciclo e non viene aggiunto alla somma.