Switch in Go

L’istruzione switch in Go e un costrutto di controllo condizionale molto versatile e piu potente rispetto alle sue controparti in altri linguaggi. In Go, lo switch non richiede break esplicito alla fine di ogni caso, i casi non devono essere costanti e i valori coinvolti non devono necessariamente essere interi. In questa guida esploreremo tutte le varianti dello switch in Go.

Switch di Base

La forma base dello switch confronta un’espressione con una serie di valori possibili.

package main

import "fmt"

func main() {
    giorno := "mercoledi"

    switch giorno {
    case "lunedi":
        fmt.Println("Inizio settimana")
    case "mercoledi":
        fmt.Println("Meta settimana")
    case "venerdi":
        fmt.Println("Quasi weekend")
    case "sabato", "domenica":
        fmt.Println("Weekend!")
    default:
        fmt.Println("Un giorno qualsiasi della settimana")
    }
}

A differenza del C e del Java, in Go ogni case termina automaticamente senza bisogno di break. L’esecuzione non prosegue al caso successivo.

Switch con Valori Multipli in un Case

Un singolo case puo contenere piu valori separati da virgola.

mese := 4

switch mese {
case 1, 2, 3:
    fmt.Println("Primo trimestre")
case 4, 5, 6:
    fmt.Println("Secondo trimestre")
case 7, 8, 9:
    fmt.Println("Terzo trimestre")
case 10, 11, 12:
    fmt.Println("Quarto trimestre")
default:
    fmt.Println("Mese non valido")
}

Switch Senza Condizione

Lo switch senza espressione e equivalente a switch true. Questo permette di scrivere catene di if-else in modo piu pulito e leggibile.

temperatura := 28

switch {
case temperatura < 0:
    fmt.Println("Sotto zero, molto freddo")
case temperatura < 15:
    fmt.Println("Fresco")
case temperatura < 25:
    fmt.Println("Piacevole")
case temperatura < 35:
    fmt.Println("Caldo")
default:
    fmt.Println("Molto caldo")
}

Questa forma e molto utilizzata quando le condizioni non sono semplici confronti di uguaglianza.

Switch con Inizializzazione

Come per l’istruzione if, anche lo switch supporta una short statement prima dell’espressione.

import "time"

switch ora := time.Now().Hour(); {
case ora < 12:
    fmt.Println("Buongiorno!")
case ora < 18:
    fmt.Println("Buon pomeriggio!")
default:
    fmt.Println("Buonasera!")
}

La variabile ora e visibile solo all’interno del blocco switch.

La Parola Chiave fallthrough

In Go, se si desidera che l’esecuzione prosegua al caso successivo (come avviene per default in C), si usa la parola chiave fallthrough.

numero := 5

switch {
case numero > 3:
    fmt.Println("Maggiore di 3")
    fallthrough
case numero > 6:
    fmt.Println("Questo viene stampato anche se numero non e > 6")
}

Output:

Maggiore di 3
Questo viene stampato anche se numero non e > 6

Attenzione: fallthrough esegue incondizionatamente il caso successivo, senza valutarne la condizione. Per questo motivo va usato con cautela.

Type Switch

Il type switch e una forma speciale di switch che confronta i tipi anziche i valori. E particolarmente utile quando si lavora con interfacce.

func descriviTipo(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("Il doppio di %d e %d\n", v, v*2)
    case string:
        fmt.Printf("La stringa %q ha lunghezza %d\n", v, len(v))
    case bool:
        fmt.Printf("Valore booleano: %t\n", v)
    case []int:
        fmt.Printf("Slice di interi con %d elementi\n", len(v))
    default:
        fmt.Printf("Tipo sconosciuto: %T\n", v)
    }
}

func main() {
    descriviTipo(42)
    descriviTipo("ciao")
    descriviTipo(true)
    descriviTipo([]int{1, 2, 3})
    descriviTipo(3.14)
}

Il type switch utilizza la sintassi i.(type) dove i deve essere un valore di tipo interfaccia. La variabile v nel blocco di ciascun case avra il tipo specifico corrispondente.

Confronto tra Switch e If-Else

In generale, quando si hanno piu condizioni da verificare, lo switch risulta piu leggibile rispetto a una catena di if-else.

// Con if-else (meno leggibile)
if stato == "attivo" {
    // ...
} else if stato == "sospeso" {
    // ...
} else if stato == "eliminato" {
    // ...
}

// Con switch (piu leggibile)
switch stato {
case "attivo":
    // ...
case "sospeso":
    // ...
case "eliminato":
    // ...
}

Conclusione

Lo switch in Go e uno strumento flessibile e potente. L’assenza del break implicito riduce gli errori comuni, mentre il fallthrough esplicito offre controllo quando serve. Il type switch e fondamentale per lavorare con le interfacce in modo sicuro. Lo switch senza condizione rappresenta un’alternativa elegante alle lunghe catene di if-else.