• FOR

il costrutto for è un costrutto iterativo e consente di iterare un comando n volte fino a che è valida la condizione di controllo

package main
import "fmt"
const limite = 5
// Stampa - commento
func main() {
	for i := 0; i < limite; i++ {
		fmt.Println(i)
	}
}

nel ciclo for ho inizializzato la variabile i con 0 (Non ho esplicitato il tipo perchè Go lo desume da solo), ho definivo la condizione per continuare l’iterazione (i deve essere minore della costante limite) e ho definito la regola di incremento ( in questo caso i cresce di una unità per ogni iterazione). Rispetto ad altri linguaggi come java non sono richieste parentesi per chiudere i comandi di inizializzazione del for, mentre sono obbligatorie le parentesi {} per racchiudere il blocco di operazioni da effettuare.

La condizione di inizializzazione e la condizione di incremento sono opzionali, pertanto posso scrivere il codice in questo, rendendo il codice equivalente ad un costrutto while.

j := 0
for j < limite {
	fmt.Println(j)
	j = j + 1
}

Anche la condizione di uscita può essere omessa, ottenendo così un ciclo virtualmente infinito che può essere pilotato tramite il comando break che interrompe l’esecuzione.

z := 0
for {
	z = z + 1
	fmt.Println(z)
	if z == 5 {
		break
	}
}

Insieme al comando break può essere usato il comando continue che permette di saltare l’iterazione corrente e andare alla prossima.

• IF

Il costrutto IF è un costrutto di seleziona e consente di eseguire il codice contenuto nelle sue parentesi {} al verificare di una condizione booleana. Se guardate il codice precedente quando il contatore vale 5 il sistema interrompe il ciclo con il comando break.

Tramite il comando else è possibile definire un blocco di operazioni alternativo ed inoltre è possibile all’interno del blocco if definire una assegnazione ad una variabile che sarà visibile solo nel blocco if.

z := 0
for {
	z = z + 1
	if d := z; d == 5 {
		fmt.Println("fine")
		break
	} else {
		fmt.Println(d)
	}
}

Nel blocco ho introdotto una variabile d inizializzata con il valore di z e ho definito una condizione alternativa a quella di uscita, grazie alla quale stampo il valore corrente dell’indice.

• SWITCH

Il costrutto switch è un costrutto di selezione e ci viene in aiuto quando dobbiamo gestire la verifica di n possibili valori. Invece di usare tanti if/else annidati lo switch case ci consente di gestire in modo elegante la casistisca descritta.

switch z {
case 1:
	fmt.Println(1)
case 2:
	fmt.Println(2)
case 3, 4:
	fmt.Println("3 o 4")
case 1 * 5:
	fmt.Println("5")
default:
	fmt.Println("default")
}

Nel blocco sopra sto verificando il valore di z, gestendo le casistiche 1 e 2 con apposito output, per gli altri valori viene stampato il valore default. Quando la condizione viene riscontrata il sistema esegue il codice relativo, a differenza di altri linquaggi come JAVA non è necessario specificare la chiave break. Nella clausola case possono essere presenti più condizioni separate da virgola ed è possibile inserire l’output di una funzione, l’importante che il tipo sia dello stesso tipo delle altre clausole.

E’ possibile anche omettere la condizione da verificare ottenendo un modo più elegante per scrivere degli if/else in cascata specificando la regola di ingresso a livello del blocco case. Lo stesso codice di sopra può essere riscritto come segue

switch {
case z == 1:
	fmt.Println(1)
case z == 2:
	fmt.Println(2)
case z == 3 || z == 4:
	fmt.Println("3 o 4")
case z == 1*5:
	fmt.Println("5")
default:
	fmt.Println("default")
}

• DEFER

Il costrutto DEFER è un comando interessante. Consente di eseguire un codice alla fine del programma. Agisce come una pila con una logica di tipo First In Last Out, pertanto il primo comando inserito sarà l’ultimo ad essere eseguito.

package main

import "fmt"

const limite = 5

func main() {

	defer fmt.Println("Fatto quello che c'era da fare")
	defer fmt.Println("Sto per scrivere il penultimo messaggio")

	for i := 0; i < limite; i++ {
		fmt.Println(i)
	}

	j := 0
	for j < limite {
		fmt.Println(j)
		j = j + 1
	}

	var z int = 0
	for {
		z = z + 1
		if d := z; d == 5 {
			fmt.Println("fine")
			break
		} else {
			fmt.Println(d)
		}
	}

	switch z {
	case 1:
		fmt.Println(1)
	case 2:
		fmt.Println(2)
	case 3, 4:
		fmt.Println("3 o 4")
	case 1 * 5:
		fmt.Println("5")
	default:
		fmt.Println("default")
	}

	switch {
	case z == 1:
		fmt.Println(1)
	case z == 2:
		fmt.Println(2)
	case z == 3 || z == 4:
		fmt.Println("3 o 4")
	case z == 1*5:
		fmt.Println("5")
	default:
		fmt.Println("default")
	}
}

Ottenendo così l’output atteso

0
1
2
3
4
0
1
2
3
4
1
2
3
4
fine
5
5
Sto per scrivere il penultimo messaggio
Fatto quello che c'era da fare