Costrutti di Controllo Flusso

Control

Ciclo:

Tipici costrutti di altri linguaggi: while, do … while, for, foreach
Il linguaggio Go ha solo for
Funziona in più modi e con sintassi leggermente diversa da altri linguaggi

Decisione:

if-else
Attenzione alla sintassi molto particolare

Decisione multipla:

switch
E’ diverso da altri linguaggi ed è molto usato
Non è completamente sostituibile con una catena if ... else if … else
Usato spesso in congiunzione con select

Costrutti di ciclo

for

L'unico costrutto di ciclo è for, che viene in tre varianti:

(050for.go):

package main

import "fmt"

func main() {

	// E' l'unico costrutto di ciclo in go
	// Tipo 1: for semplice == while(C)
	// Non ci sono parentesi per l'argomento
	// Le graffe sono obbligatorie
	i := 1
	for i <= 3 {
		fmt.Println(i)
		i = i + 1
	}

	// Tipo 2 == for(C)
	// Argomenti separati da ;
	// operazioni iniziali; condizione di continuazione;
	// operazioni al termine di ciascun ciclo
	// più operazioni separate da ,
	for j := 7; j <= 9; j++ {
		fmt.Println(j)
	}

	// Tipo 3: loop infinito
	for {
		fmt.Println("loop")
		// uscita dal ciclo
		break
	}
}

La prima variante è l'equivalente di un while, e richiede sia una inizializzazione della variabile di controllo prima del ciclo che un incremento all'interno del ciclo.

La seconda variante equivale all'equivalente costrutto del linguaggio C, con le tre componenti, separate da punto e virgola:

operazioni prima del ciclo
condizione di continuazione del ciclo
operazioni al termine di ogni ciclo

La terza variante è un loop infinito. Notare che il comando break esce dal ciclo.
Un equivalente comando continue salta le rimanenti istruzioni e rientra in ciclo.
I comandi break e continue sono solitamente governati da un if.

Notare che non si mettono parentesi tonde intorno alla condizione logica.

Notare altresì che le parentesi graffe sono sempre obbligatorie.

Costrutti di Decisione

if-else

(060if-else.go):

package main

import "fmt"

func main() {

	// Simile a molti altri linguaggi
	// Le graffe sono obbligatorie
	if 7%2 == 0 {
		fmt.Println("7 is even")
	} else {
		fmt.Println("7 is odd")
	}

	// La branca else può non esserci
	if 8%4 == 0 {
		fmt.Println("8 is divisible by 4")
	}

	// Assegnazioni possono precedere la condizione
	// Variabili locali al costrutto if
	if num := 9; num < 0 {
		fmt.Println(num, "is negative")
	} else if num < 10 {
		fmt.Println(num, "has 1 digit")
	} else {
		fmt.Println(num, "has multiple digits")
	}
}

// Note that you don't need parentheses around conditions
// in Go, but that the braces are required.

Non ci vogliono parentesi tonde intorno alla condizione logica dello if. Le parentesi graffe sono sempre obbligatorie.

La clausola else è opzionale.

Dopo lo else può essere concatenato un ulteriore if.

Una particolarità del Go è la possibilità di porre istruzioni di definizione di variabili dopo la parola chiave if e prima della condizione logica.
Tali variabili sono locali al for.

Costrutti di Decisione Multipla

switch

Il costrutto switch è simile a quello di altri linguaggi discendenti dal C, ma fornisce più possibilità. Esempo:

(070switch):

package main

import "fmt"
import "time"

func main() {

	// Costrutto switch
	i := 2
	fmt.Print("write ", i, " as ")
	// Variabile di paragone
	switch i {
	// Valore con cui viene paragonata
	case 1:
		fmt.Println("one")
		// Non c'è 'cascading' come in C
		// Non c'è il break
	case 2:
		fmt.Println("two")
	case 3:
		fmt.Println("three")
	}

	switch time.Now().Weekday() {
	// Più valori di paragone separati da ,
	case time.Saturday, time.Sunday:
		fmt.Println("it's the weekend")
	// default soddisfa sempre
	// logicamente è l'ultimo paragone
	default:
		fmt.Println("it's a weekday")
	}

	// Costrutto equivalente a if-else
	t := time.Now()
	fmt.Println(t)
	// Manca la variabile di paragone
	switch {
	// Il valore è booleano
	case t.Hour() < 12:
		fmt.Println("it's before noon")
	default:
		fmt.Println("it's after noon")
	}
}

Sia l'argomento dello switch che l'argomento del case non sono limitati a costanti o variabili, ma possono essere espressioni, le quali però devono avere un valore preciso.

Se lo switch non ha argomenti, allora ogni case deve avere per argomento un'espressione condizionale (booleana). Il costrutto equivale in questo caso ad un for.

case può coprire più casi, separati da una virgola

Al termine del paragrafo di un case vi è un'uscita dal costrutto switch,non è necessario un break.

Il caso default non ha argomenti, è opzionale, e va naturalmente posto per ultimo.

Go Base