Não como recurso da linguagem. Não existe a palavra-chave enum. O substituto idiomático é um tipo nomeado mais um bloco de constantes tipadas, normalmente numeradas com iota: O tipo dá assinaturas legíveis e um lugar para pendurar métodos como String(). Ele não impede ninguém de escrever Color(42), então valide os valores que vêm de fora.

Docs executáveis de Go: Enums e iota

Q: O que é iota em Go?

iota é um identificador pré-declarado que vale o índice da linha atual (especificação de constante) dentro de um bloco const, começando em 0. Ele volta a 0 em cada novo bloco const. Quando uma linha omite a expressão, o Go repete a expressão anterior com o próximo iota, e é isso que faz Red = iota; Green; Blue gerar 0, 1, 2.

Q: Como fazer o iota começar em 1?

Escreva First Kind = iota + 1 na primeira linha, ou pule o zero com um identificador em branco: _ = iota e depois First. Muitos programadores Go preferem manter o 0 e chamá-lo de Unknown ou Invalid, para que uma variável não inicializada (cujo valor zero é 0) fique claramente fora das opções reais.

Q: Como imprimir um enum como string em Go?

Dê ao tipo um método String() string. O fmt o chama para %v, %s e Println, então fmt.Println(Green) imprime Green em vez de 1. Você pode escrever o método à mão com um switch ou um array, ou gerá-lo com go run golang.org/x/tools/cmd/stringer@latest -type=Color.

Q: Como converter uma string em enum em Go?

Escreva uma função de parsing que procura a string, normalmente em um map[string]Color ou em um switch, e devolve um erro para entradas desconhecidas: func ParseColor(s string) (Color, error). Implementar UnmarshalText com a mesma lógica faz JSON, flags e carregadores de configuração usarem a função automaticamente.

Go não tem a palavra-chave enum. Você monta um enum com duas peças: um tipo nomeado e um bloco const de valores desse tipo, numerados com 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 cada linha seguinte vale um a mais. O tipo nomeado Weekday é o que faz disso um enum, e não uma lista de números: isWeekend diz na assinatura o que espera, e métodos podem ser acrescentados ao tipo. A saída imprime 1 5 6 porque nada ainda diz ao Go como exibir um Weekday como texto. Isso vem mais abaixo.

Como o iota funciona

iota é um contador que o compilador oferece dentro de um bloco const. Duas regras explicam todos os truques construídos em cima dele:

iota vale o índice da linha atual no bloco, começando em 0, e volta a 0 em cada novo bloco const.
Uma linha sem = expressão repete a expressão e o tipo da linha anterior, avaliados com o novo iota.

Então Monday, acima, é um atalho para Monday Weekday = iota, com iota valendo 1. Como a expressão é repetida, ela pode ser qualquer expressão constante, não só 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 linhas, não nomes: duas constantes na mesma linha compartilham um mesmo valor de iota, como mostram X e Y.

Começar em 1, e por que talvez não

Uma variável de um tipo enum que ninguém definiu guarda 0, o seu valor zero. Se 0 é um valor real como Sunday, você não consegue diferenciar "o usuário escolheu domingo" de "o campo nunca foi preenchido". Três correções comuns:

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)
}

A opção 1 é a mais comum em código de produção, e os enums Go gerados pelo protobuf a seguem (..._UNSPECIFIED = 0). O valor zero passa a significar algo honesto.

Pulando valores

O identificador em branco _ consome um valor de iota sem criar um nome. Use-o para deixar lacunas, por exemplo para bater com números definidos por um protocolo ou para aposentar um valor sem renumerar o resto:

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 os números são fixados por uma especificação externa, como estes opcodes do WebSocket, escrevê-los explicitamente (OpClose Opcode = 8) costuma ser mais claro do que contar linhas em branco. O iota é para valores cujos números exatos não importam.

Nunca reordene nem insira itens em uma lista de iota cujos números estejam guardados em um banco de dados, em um arquivo ou enviados pela rede. Acrescentar uma linha no meio desloca todos os valores seguintes. Acrescente valores novos no final, ou atribua os números explicitamente.

Acrescentando um método String

Dê ao tipo um método String() string e o fmt passa a usá-lo em %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)
}

Dois detalhes desse método importam:

A verificação de limites. Sem ela, Weekday(9).String() causa panic de índice fora da faixa, e isso vai acontecer em algum momento, porque nada impede quem chama de criar Weekday(9).
O int(d) dentro do Sprintf. Formatar o próprio d com %d não tem problema, mas formatá-lo com %v chamaria String() de novo e entraria em recursão até estourar a pilha.

%d continua imprimindo o número, então você tem as duas formas: Wednesday is day 3.

Gerando o String com o stringer

Para listas longas, a ferramenta stringer escreve o método por você:

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

go generate ./...

Ela cria weekday_string.go com uma implementação compacta de String(), mais uma verificação em tempo de compilação que quebra o build se as constantes mudarem sem que o arquivo seja gerado de novo. A flag -linecomment usa um comentário no fim da linha como nome, o que ajuda com nomes que têm espaços.

Validando valores

Um enum em Go não é fechado. Qualquer valor do tipo subjacente pode ser convertido para ele, e constantes não tipadas são convertidas implicitamente:

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

Então verifique os valores que vêm de fora do seu código (JSON, bancos de dados, flags, outros pacotes):

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)
	}
}

A sentinela não exportada colorCount no fim do bloco mantém o IsValid correto quando você acrescenta cores novas, já que ela sempre fica uma posição depois do último valor real.

switch sobre um enum

Enums normalmente são consumidos por um switch. Go não verifica se um switch cobre todos os valores, então acrescente um default que reporte a surpresa:

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

O linter de terceiros exhaustive (incluído no golangci-lint) reporta switches sobre tipos enum aos quais falta algum case, o que dá a maior parte do que uma verificação de enum exaustiva dá em outras linguagens.

Enums de bit flags

Quando os valores se combinam, como permissões, use um bit por valor com 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 flags, & as testa e &^ (o operador AND NOT do Go) as limpa. Um tipo subjacente sem sinal é a escolha certa aqui: uint8 comporta 8 flags, uint64 comporta 64.

Enums de string

Quando o valor é guardado ou enviado como texto de qualquer forma, um tipo baseado em string evita a camada de conversão:

type Env string

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

Os valores são impressos e serializados de forma legível sem nenhum método String(), e uma coluna do banco guarda "prod" em vez de um número que depende da ordem de declaração. Os contras: as comparações são comparações de string, bit flags são impossíveis e a validação continua sendo sua, já que Env("banana") também compila.

Enums e JSON

Um enum inteiro é serializado como número por padrão. Para ler e escrever nomes, implemente encoding.TextMarshaler e encoding.TextUnmarshaler. O encoding/json os usa para valores e para chaves de map:

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 tem receiver de valor, então funciona tanto em Level quanto em *Level; UnmarshalText precisa de receiver ponteiro porque altera o valor. Os mesmos dois métodos fazem o tipo funcionar com o TextVar do pacote flag e com a maioria das bibliotecas de configuração.

Armadilhas

Conversão implícita de literais. Uma função que recebe um Weekday também aceita a constante não tipada 42. Só valores tipados de outro tipo são rejeitados.
Esquecer o tipo na primeira linha. Em const ( Red = iota; Green; Blue ) as três são constantes inteiras não tipadas, não valores Color, então os métodos de Color não se aplicam a elas. Escreva Red Color = iota para que a expressão repetida carregue o tipo.
Reordenar enums guardados. Inserir um valor no meio de um bloco iota muda em silêncio os números já gravados em outros lugares.
Recursão no String. Dentro de String(), nunca formate o receiver com %v ou %s. Converta para o tipo subjacente antes.

Perguntas frequentes

Go tem enums?

Não como recurso da linguagem. Não existe a palavra-chave enum. O substituto idiomático é um tipo nomeado mais um bloco de constantes tipadas, normalmente numeradas com iota:

type Color int

const (
	Red Color = iota
	Green
	Blue
)

O tipo dá assinaturas legíveis e um lugar para pendurar métodos como String(). Ele não impede ninguém de escrever Color(42), então valide os valores que vêm de fora.

O que é iota em Go?

iota é um identificador pré-declarado que vale o índice da linha atual (especificação de constante) dentro de um bloco const, começando em 0. Ele volta a 0 em cada novo bloco const. Quando uma linha omite a expressão, o Go repete a expressão anterior com o próximo iota, e é isso que faz Red = iota; Green; Blue gerar 0, 1, 2.

Como fazer o iota começar em 1?

Escreva First Kind = iota + 1 na primeira linha, ou pule o zero com um identificador em branco: _ = iota e depois First. Muitos programadores Go preferem manter o 0 e chamá-lo de Unknown ou Invalid, para que uma variável não inicializada (cujo valor zero é 0) fique claramente fora das opções reais.

Como imprimir um enum como string em Go?

Dê ao tipo um método String() string. O fmt o chama para %v, %s e Println, então fmt.Println(Green) imprime Green em vez de 1. Você pode escrever o método à mão com um switch ou um array, ou gerá-lo com go run golang.org/x/tools/cmd/stringer@latest -type=Color.

Como converter uma string em enum em Go?

Escreva uma função de parsing que procura a string, normalmente em um map[string]Color ou em um switch, e devolve um erro para entradas desconhecidas: func ParseColor(s string) (Color, error). Implementar UnmarshalText com a mesma lógica faz JSON, flags e carregadores de configuração usarem a função automaticamente.

Conceitos relacionados