Non come funzionalità del linguaggio. Non esiste una parola chiave enum. Il sostituto idiomatico è un tipo con nome più un blocco di costanti tipizzate, di solito numerate con iota: Il tipo ti dà firme leggibili e un posto a cui agganciare metodi come String(). Non impedisce a nessuno di scrivere Color(42), quindi valida i valori che arrivano dall'esterno.

Guida Go interattiva: Enum e iota

Q: Cos'è iota in Go?

iota è un identificatore predichiarato che vale l'indice della riga corrente (la specifica di costante) dentro un blocco const, a partire da 0. Torna a 0 in ogni nuovo blocco const. Quando una riga omette la sua espressione, Go ripete l'espressione precedente con il valore successivo di iota, ed è per questo che Red = iota; Green; Blue produce 0, 1, 2.

Q: Come faccio a far partire iota da 1?

Scrivi First Kind = iota + 1 sulla prima riga, oppure salta lo zero con l'identificatore vuoto: _ = iota e poi First. Molti programmatori Go preferiscono invece tenere lo 0 e chiamarlo Unknown o Invalid, così una variabile non inizializzata (il cui valore zero è 0) non è chiaramente una scelta reale.

Q: Come stampo un enum come stringa in Go?

Dai al tipo un metodo String() string. fmt lo chiama per %v, %s e Println, quindi fmt.Println(Green) stampa Green invece di 1. Puoi scrivere il metodo a mano con uno switch o un array, oppure generarlo con go run golang.org/x/tools/cmd/stringer@latest -type=Color.

Q: Come converto una stringa in un enum in Go?

Scrivi una funzione di parsing che cerca la stringa, di solito in una map[string]Color o con uno switch, e restituisce un errore per un input sconosciuto: func ParseColor(s string) (Color, error). Implementare UnmarshalText con la stessa logica fa sì che JSON, flag e caricatori di configurazione la usino automaticamente.

Go non ha una parola chiave enum. Costruisci un enum con due pezzi: un tipo con nome e un blocco const di valori di quel tipo, numerati con iota.

package main

import "fmt"

type Weekday int

const (
	Sunday    Weekday = iota // 0
	Monday                   // 1
	Tuesday                  // 2
	Wednesday                // 3
	Thursday                 // 4
	Friday                   // 5
	Saturday                 // 6
)

func isWeekend(d Weekday) bool {
	return d == Saturday || d == Sunday
}

func main() {
	fmt.Println(Monday, Friday, Saturday)
	fmt.Println("Saturday is weekend:", isWeekend(Saturday))
	fmt.Println("Tuesday is weekend:", isWeekend(Tuesday))
}

Sunday vale 0, e ogni riga successiva vale uno in più. È il tipo con nome Weekday che rende tutto questo un enum invece di una lista di numeri: isWeekend dice nella sua firma cosa si aspetta, e al tipo si possono aggiungere metodi. L'output stampa 1 5 6 perché niente dice ancora a Go come mostrare un Weekday come testo. Ci arriviamo più avanti.

Come funziona iota

iota è un contatore che il compilatore fornisce dentro un blocco const. Due regole spiegano ogni trucco basato su di esso:

iota vale l'indice della riga corrente nel blocco, a partire da 0, e torna a 0 in ogni nuovo blocco const.
Una riga senza = expression ripete l'espressione e il tipo della riga precedente, valutati con il nuovo iota.

Quindi Monday qui sopra è l'abbreviazione di Monday Weekday = iota, con iota che ora vale 1. Poiché l'espressione viene ripetuta, può essere qualsiasi espressione costante, non solo iota:

package main

import "fmt"

type Size int64

const (
	_  Size = iota             // 0, discarded
	KB Size = 1 << (10 * iota) // 1 << 10
	MB                         // 1 << 20
	GB                         // 1 << 30
	TB                         // 1 << 40
)

const (
	A = iota * 10 // 0
	B             // 10
	C             // 20
)

const (
	X, Y = iota, iota + 100 // both on line 0: 0, 100
	Z, W                    // line 1: 1, 101
)

func main() {
	fmt.Println(KB, MB, GB, TB)
	fmt.Println(A, B, C)
	fmt.Println(X, Y, Z, W)
}

iota conta le righe, non i nomi: due costanti sulla stessa riga condividono un unico valore di iota, come mostrano X e Y.

Partire da 1, e perché potresti non volerlo

Una variabile di tipo enum che nessuno ha impostato contiene 0, il suo valore zero. Se 0 è un valore reale come Sunday, non puoi distinguere "l'utente ha scelto domenica" da "il campo non è mai stato compilato". Tre soluzioni comuni:

package main

import "fmt"

type Status int

// Option 1: reserve 0 for an explicit "unknown" value.
const (
	StatusUnknown Status = iota
	StatusActive
	StatusSuspended
	StatusDeleted
)

type Level int

// Option 2: start at 1 with iota + 1.
const (
	Low Level = iota + 1
	Medium
	High
)

type Priority int

// Option 3: skip 0 with the blank identifier.
const (
	_ Priority = iota
	P1
	P2
	P3
)

type Account struct {
	Name   string
	Status Status
}

func main() {
	var a Account // Status was never set
	fmt.Println(a.Status == StatusUnknown)
	fmt.Println(Low, Medium, High)
	fmt.Println(P1, P2, P3)
}

L'opzione 1 è la più comune nel codice di produzione, e gli enum Go generati da protobuf la seguono (..._UNSPECIFIED = 0). Il valore zero ha così un significato onesto.

Saltare valori

L'identificatore vuoto _ consuma un valore di iota senza creare un nome. Usalo per lasciare dei buchi, per esempio per rispettare numeri definiti da un protocollo o per ritirare un valore senza rinumerare gli altri:

type Opcode byte

const (
	OpContinue Opcode = iota // 0
	OpText                   // 1
	OpBinary                 // 2
	_                        // 3, reserved
	_                        // 4, reserved
	_                        // 5, reserved
	_                        // 6, reserved
	_                        // 7, reserved
	OpClose                  // 8
	OpPing                   // 9
	OpPong                   // 10
)

Quando i numeri sono fissati da una specifica esterna, come per questi opcode WebSocket, scriverli esplicitamente (OpClose Opcode = 8) è spesso più chiaro che contare i vuoti. iota serve per valori di cui non ti interessano i numeri esatti.

Non riordinare né inserire mai elementi in una lista con iota i cui numeri vengono memorizzati in un database o in un file, o inviati sulla rete. Aggiungere una riga nel mezzo sposta tutti i valori successivi. Aggiungi i nuovi valori in fondo, oppure assegna i numeri esplicitamente.

Aggiungere un metodo String

Dai al tipo un metodo String() string e fmt lo userà per %v, %s e Println:

package main

import "fmt"

type Weekday int

const (
	Sunday Weekday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
)

var weekdayNames = [...]string{
	"Sunday", "Monday", "Tuesday", "Wednesday",
	"Thursday", "Friday", "Saturday",
}

func (d Weekday) String() string {
	if d < 0 || int(d) >= len(weekdayNames) {
		return fmt.Sprintf("Weekday(%d)", int(d))
	}
	return weekdayNames[d]
}

func main() {
	fmt.Println(Monday, Friday)
	fmt.Printf("%v is day %d\n", Wednesday, Wednesday)
	fmt.Println(Weekday(9)) // out of range, still prints something useful

	today := Saturday
	fmt.Println("today:", today)
}

In quel metodo contano due dettagli:

Il controllo dei limiti. Senza di esso, Weekday(9).String() va in panic con un indice fuori intervallo, e prima o poi succederà, perché niente impedisce a un chiamante di creare Weekday(9).
L'int(d) dentro Sprintf. Formattare d stesso con %d va bene, ma formattarlo con %v chiamerebbe di nuovo String() e andrebbe in ricorsione fino all'overflow dello stack.

%d stampa comunque il numero, quindi ottieni entrambe le forme: Wednesday is day 3.

Generare String con stringer

Per liste lunghe, lo strumento stringer scrive il metodo al posto tuo:

//go:generate go run golang.org/x/tools/cmd/stringer@latest -type=Weekday

go generate ./...

Crea weekday_string.go con un'implementazione compatta di String(), più un controllo in fase di compilazione che rompe la build se le costanti cambiano senza rigenerare il file. Il flag -linecomment usa un commento a fine riga come nome, comodo per nomi con spazi.

Validare i valori

Un enum Go non è chiuso. Qualsiasi valore del tipo sottostante si può convertire in esso, e le costanti non tipizzate si convertono implicitamente:

var d Weekday = 42     // compiles
d = Weekday(userInput) // compiles

Quindi controlla i valori che arrivano da fuori dal tuo codice (JSON, database, flag, altri package):

package main

import (
	"fmt"
	"strings"
)

type Color int

const (
	ColorUnknown Color = iota
	Red
	Green
	Blue
	colorCount // unexported sentinel: always last
)

var colorNames = map[Color]string{
	Red:   "red",
	Green: "green",
	Blue:  "blue",
}

func (c Color) String() string {
	if name, ok := colorNames[c]; ok {
		return name
	}
	return fmt.Sprintf("Color(%d)", int(c))
}

func (c Color) IsValid() bool {
	return c > ColorUnknown && c < colorCount
}

func ParseColor(s string) (Color, error) {
	for c, name := range colorNames {
		if strings.EqualFold(name, s) {
			return c, nil
		}
	}
	return ColorUnknown, fmt.Errorf("unknown color %q", s)
}

func main() {
	fmt.Println(Green.IsValid(), Color(7).IsValid(), ColorUnknown.IsValid())

	for _, in := range []string{"BLUE", "purple"} {
		c, err := ParseColor(in)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("parsed:", c)
	}
}

La sentinella non esportata colorCount alla fine del blocco mantiene corretto IsValid quando aggiungi nuovi colori, perché si trova sempre una posizione dopo l'ultimo valore reale.

Usare uno switch su un enum

Gli enum di solito vengono usati in uno switch. Go non controlla che uno switch copra ogni valore, quindi aggiungi un default che segnali l'imprevisto:

func (c Color) Hex() string {
	switch c {
	case Red:
		return "#ff0000"
	case Green:
		return "#00ff00"
	case Blue:
		return "#0000ff"
	default:
		return "#000000"
	}
}

Il linter di terze parti exhaustive (incluso in golangci-lint) segnala gli switch su tipi enum a cui manca un caso, il che ti dà gran parte di ciò che offre il controllo di esaustività degli enum in altri linguaggi.

Enum come flag di bit

Quando i valori si combinano, come i permessi, usa un bit per valore con 1 << iota:

package main

import (
	"fmt"
	"strings"
)

type Permission uint8

const (
	Read    Permission = 1 << iota // 1
	Write                          // 2
	Execute                        // 4
)

func (p Permission) Has(flag Permission) bool {
	return p&flag != 0
}

func (p Permission) String() string {
	if p == 0 {
		return "none"
	}
	var parts []string
	for _, f := range []struct {
		flag Permission
		name string
	}{{Read, "read"}, {Write, "write"}, {Execute, "execute"}} {
		if p.Has(f.flag) {
			parts = append(parts, f.name)
		}
	}
	return strings.Join(parts, "|")
}

func main() {
	p := Read | Write
	fmt.Println(p, int(p))
	fmt.Println("can write:", p.Has(Write))
	fmt.Println("can execute:", p.Has(Execute))

	p |= Execute // add a flag
	p &^= Write  // remove a flag (AND NOT)
	fmt.Println(p)

	var none Permission
	fmt.Println(none)
}

| combina i flag, & li verifica e &^ (l'operatore AND NOT di Go) li azzera. Qui la scelta giusta è un tipo sottostante senza segno: uint8 contiene 8 flag, uint64 ne contiene 64.

Enum di stringhe

Quando il valore viene comunque memorizzato o inviato come testo, un tipo basato su stringhe evita lo strato di conversione:

type Env string

const (
	EnvDev     Env = "dev"
	EnvStaging Env = "staging"
	EnvProd    Env = "prod"
)

I valori si stampano e si serializzano in modo leggibile senza un metodo String(), e una colonna del database contiene "prod" invece di un numero che dipende dall'ordine di dichiarazione. I compromessi: i confronti sono confronti tra stringhe, i flag di bit sono impossibili e la validazione resta a tuo carico, perché anche Env("banana") compila.

Enum e JSON

Un enum intero viene serializzato come numero per impostazione predefinita. Per leggere e scrivere invece i nomi, implementa encoding.TextMarshaler ed encoding.TextUnmarshaler. encoding/json li usa per i valori e per le chiavi delle mappe:

package main

import (
	"encoding/json"
	"fmt"
)

type Level int

const (
	LevelUnknown Level = iota
	LevelLow
	LevelHigh
)

var levelNames = []string{"unknown", "low", "high"}

func (l Level) String() string {
	if l < 0 || int(l) >= len(levelNames) {
		return fmt.Sprintf("Level(%d)", int(l))
	}
	return levelNames[l]
}

func (l Level) MarshalText() ([]byte, error) {
	return []byte(l.String()), nil
}

func (l *Level) UnmarshalText(b []byte) error {
	for i, name := range levelNames {
		if name == string(b) {
			*l = Level(i)
			return nil
		}
	}
	return fmt.Errorf("invalid level %q", b)
}

type Alert struct {
	Message string `json:"message"`
	Level   Level  `json:"level"`
}

func main() {
	out, err := json.Marshal(Alert{Message: "disk full", Level: LevelHigh})
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(string(out))

	var a Alert
	err = json.Unmarshal([]byte(`{"message":"cpu","level":"low"}`), &a)
	fmt.Println(a.Level, err)

	err = json.Unmarshal([]byte(`{"message":"cpu","level":"extreme"}`), &a)
	fmt.Println(err)
}

MarshalText ha un receiver per valore, quindi funziona sia su Level sia su *Level; UnmarshalText ha bisogno di un receiver puntatore perché modifica il valore. Gli stessi due metodi fanno funzionare il tipo con TextVar del package flag e con la maggior parte delle librerie di configurazione.

Insidie

Conversione implicita dei letterali. Una funzione che accetta un Weekday accetta anche la costante non tipizzata 42. Vengono rifiutati solo i valori tipizzati di un altro tipo.
Dimenticare il tipo sulla prima riga. In const ( Red = iota; Green; Blue ) tutte e tre sono costanti intere non tipizzate, non valori Color, quindi i metodi di Color non si applicano a loro. Scrivi Red Color = iota così l'espressione ripetuta porta con sé il tipo.
Riordinare enum memorizzati. Inserire un valore nel mezzo di un blocco iota cambia silenziosamente i numeri già salvati altrove.
Ricorsione in String. Dentro String(), non formattare mai il receiver con %v o %s. Convertilo prima nel tipo sottostante.

Domande frequenti

Go ha gli enum?

Non come funzionalità del linguaggio. Non esiste una parola chiave enum. Il sostituto idiomatico è un tipo con nome più un blocco di costanti tipizzate, di solito numerate con iota:

type Color int

const (
	Red Color = iota
	Green
	Blue
)

Il tipo ti dà firme leggibili e un posto a cui agganciare metodi come String(). Non impedisce a nessuno di scrivere Color(42), quindi valida i valori che arrivano dall'esterno.

Cos'è iota in Go?

iota è un identificatore predichiarato che vale l'indice della riga corrente (la specifica di costante) dentro un blocco const, a partire da 0. Torna a 0 in ogni nuovo blocco const. Quando una riga omette la sua espressione, Go ripete l'espressione precedente con il valore successivo di iota, ed è per questo che Red = iota; Green; Blue produce 0, 1, 2.

Come faccio a far partire iota da 1?

Scrivi First Kind = iota + 1 sulla prima riga, oppure salta lo zero con l'identificatore vuoto: _ = iota e poi First. Molti programmatori Go preferiscono invece tenere lo 0 e chiamarlo Unknown o Invalid, così una variabile non inizializzata (il cui valore zero è 0) non è chiaramente una scelta reale.

Come stampo un enum come stringa in Go?

Dai al tipo un metodo String() string. fmt lo chiama per %v, %s e Println, quindi fmt.Println(Green) stampa Green invece di 1. Puoi scrivere il metodo a mano con uno switch o un array, oppure generarlo con go run golang.org/x/tools/cmd/stringer@latest -type=Color.

Come converto una stringa in un enum in Go?

Scrivi una funzione di parsing che cerca la stringa, di solito in una map[string]Color o con uno switch, e restituisce un errore per un input sconosciuto: func ParseColor(s string) (Color, error). Implementare UnmarshalText con la stessa logica fa sì che JSON, flag e caricatori di configurazione la usino automaticamente.

Concetti correlati