Dokumentasi Go interaktif: Enum dan iota

Q: Apakah Go punya enum?

Tidak sebagai fitur bahasa. Tidak ada kata kunci enum. Penggantinya yang idiomatis adalah tipe bernama ditambah blok konstanta bertipe, biasanya dinomori dengan iota: Tipe itu memberimu signature yang mudah dibaca dan tempat untuk menaruh method seperti String(). Tipe itu tidak mencegah seseorang menulis Color(42), jadi validasi nilai yang datang dari luar.

Q: Apa itu iota di Go?

iota adalah identifier bawaan yang bernilai sama dengan indeks baris saat ini (constant spec) di dalam blok const, dimulai dari 0. Nilainya kembali ke 0 di setiap blok const yang baru. Saat sebuah baris tidak menulis ekspresinya, Go mengulang ekspresi sebelumnya dengan iota berikutnya, dan itulah yang membuat Red = iota; Green; Blue menghasilkan 0, 1, 2.

Q: Bagaimana cara membuat iota mulai dari 1?

Tulis First Kind = iota + 1 di baris pertama, atau lewati nol dengan blank identifier: _ = iota lalu First. Banyak programmer Go justru mempertahankan 0 dan menamainya Unknown atau Invalid, supaya variabel yang belum diinisialisasi (zero value-nya 0) jelas bukan pilihan yang sungguhan.

Q: Bagaimana cara mencetak enum sebagai string di Go?

Beri tipe itu method String() string. fmt memanggilnya untuk %v, %s, dan Println, jadi fmt.Println(Green) mencetak Green, bukan 1. Kamu bisa menulis method itu secara manual dengan switch atau array, atau membuatnya otomatis dengan go run golang.org/x/tools/cmd/stringer@latest -type=Color.

Q: Bagaimana cara mengonversi string ke enum di Go?

Tulis fungsi parse yang mencari string tersebut, biasanya di map[string]Color atau switch, dan mengembalikan error untuk input yang tidak dikenal: func ParseColor(s string) (Color, error). Mengimplementasikan UnmarshalText dengan logika yang sama membuat JSON, flag, dan loader konfigurasi memakainya secara otomatis.

Go tidak punya kata kunci enum. Kamu membangun enum dari dua bagian: sebuah tipe bernama, dan blok const berisi nilai-nilai bertipe itu, yang dinomori dengan 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 bernilai 0, dan setiap baris berikutnya bertambah satu. Tipe bernama Weekday inilah yang membuatnya menjadi enum, bukan sekadar daftar angka: isWeekend menyatakan di signature-nya apa yang ia harapkan, dan method bisa ditambahkan ke tipe itu. Output-nya mencetak 1 5 6 karena belum ada yang memberi tahu Go cara menampilkan Weekday sebagai teks. Itu dibahas di bawah.

Cara Kerja iota

iota adalah counter yang disediakan compiler di dalam blok const. Dua aturan menjelaskan setiap trik yang dibangun di atasnya:

iota bernilai sama dengan indeks baris saat ini di dalam blok, dimulai dari 0, dan kembali ke 0 di setiap blok const yang baru.
Baris tanpa = expression mengulang ekspresi dan tipe dari baris sebelumnya, yang dievaluasi dengan iota yang baru.

Jadi Monday di atas adalah singkatan dari Monday Weekday = iota, dengan iota yang sekarang bernilai 1. Karena ekspresinya diulang, ekspresi itu bisa berupa ekspresi konstanta apa pun, tidak hanya 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 menghitung baris, bukan nama: dua konstanta di baris yang sama berbagi satu nilai iota, seperti yang ditunjukkan X dan Y.

Mulai dari 1, dan Kenapa Mungkin Tidak Perlu

Variabel bertipe enum yang tidak pernah diisi siapa pun berisi 0, yaitu zero value-nya. Kalau 0 adalah nilai yang sungguhan seperti Sunday, kamu tidak bisa membedakan "pengguna memilih Sunday" dari "field-nya tidak pernah diisi". Tiga perbaikan yang umum:

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

Opsi 1 paling umum di kode produksi, dan enum Go yang dibuat oleh protobuf mengikutinya (..._UNSPECIFIED = 0). Zero value lalu punya arti yang jujur.

Melewati Nilai

Blank identifier _ memakai satu nilai iota tanpa membuat nama. Pakai untuk meninggalkan celah, misalnya untuk menyesuaikan dengan angka yang ditetapkan sebuah protokol atau untuk memensiunkan sebuah nilai tanpa menomori ulang yang lain:

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
)

Saat angkanya sudah ditetapkan oleh spesifikasi eksternal, seperti opcode WebSocket ini, menuliskannya secara eksplisit (OpClose Opcode = 8) sering kali lebih jelas daripada menghitung blank identifier. iota dipakai untuk nilai yang angka pastinya tidak kamu pedulikan.

Jangan pernah mengubah urutan atau menyisipkan ke dalam daftar iota yang angkanya disimpan di database, file, atau dikirim lewat jaringan. Menambahkan baris di tengah menggeser setiap nilai setelahnya. Tambahkan nilai baru di akhir, atau tetapkan angkanya secara eksplisit.

Menambahkan Method String

Beri tipe itu method String() string dan fmt akan memakainya untuk %v, %s, dan 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)
}

Dua detail dalam method itu penting:

Pemeriksaan batas. Tanpa itu, Weekday(9).String() akan panic dengan index out of range, dan suatu saat itu pasti terjadi, karena tidak ada yang mencegah pemanggil membuat Weekday(9).
int(d) di dalam Sprintf. Memformat d sendiri dengan %d tidak masalah, tetapi memformatnya dengan %v akan memanggil String() lagi dan terus berulang sampai stack overflow.

%d tetap mencetak angkanya, jadi kamu mendapat kedua bentuknya: Wednesday is day 3.

Membuat String Otomatis dengan stringer

Untuk daftar yang panjang, tool stringer menulis method itu untukmu:

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

go generate ./...

Tool ini membuat weekday_string.go berisi implementasi String() yang ringkas, ditambah pemeriksaan saat kompilasi yang menggagalkan build kalau konstantanya berubah tanpa dibuat ulang. Flag -linecomment memakai komentar di akhir baris sebagai nama, yang berguna untuk nama yang mengandung spasi.

Memvalidasi Nilai

Enum di Go tidak tertutup. Nilai apa pun dari tipe dasarnya bisa dikonversi ke enum itu, dan konstanta tanpa tipe dikonversi secara implisit:

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

Jadi periksa nilai yang datang dari luar kodemu (JSON, database, flag, package lain):

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

Sentinel colorCount yang tidak diekspor di akhir blok menjaga IsValid tetap benar saat kamu menambahkan warna baru, karena posisinya selalu satu setelah nilai sungguhan yang terakhir.

Switch pada Enum

Enum biasanya dipakai lewat switch. Go tidak memeriksa apakah sebuah switch sudah mencakup setiap nilai, jadi tambahkan default yang melaporkan nilai yang tidak terduga:

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

Linter pihak ketiga exhaustive (termasuk dalam golangci-lint) melaporkan switch pada tipe enum yang melewatkan sebuah case, yang memberimu sebagian besar manfaat pemeriksaan enum yang lengkap seperti di bahasa lain.

Enum Bit Flag

Saat nilai-nilainya bisa digabung, seperti izin akses, pakai satu bit per nilai dengan 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)
}

| menggabungkan flag, & mengujinya, dan &^ (operator AND NOT di Go) menghapusnya. Tipe dasar unsigned adalah pilihan yang tepat di sini: uint8 menampung 8 flag, uint64 menampung 64.

Enum String

Saat nilainya memang disimpan atau dikirim sebagai teks, tipe berbasis string menghindari lapisan konversi:

type Env string

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

Nilainya tercetak dan terserialisasi dengan mudah dibaca tanpa method String(), dan kolom database berisi "prod", bukan angka yang bergantung pada urutan deklarasi. Kekurangannya: perbandingannya adalah perbandingan string, bit flag tidak mungkin dipakai, dan validasi tetap menjadi tanggung jawabmu, karena Env("banana") juga bisa dikompilasi.

Enum dan JSON

Enum integer diserialisasi sebagai angka secara default. Untuk membaca dan menulis namanya, implementasikan encoding.TextMarshaler dan encoding.TextUnmarshaler. encoding/json memakainya untuk nilai dan untuk key 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 punya value receiver sehingga bisa dipakai pada Level maupun *Level; UnmarshalText butuh pointer receiver karena ia mengubah nilainya. Dua method yang sama membuat tipe ini bisa dipakai dengan TextVar dari package flag dan dengan kebanyakan library konfigurasi.

Hal yang Sering Menjebak

Konversi implisit dari literal. Fungsi yang menerima Weekday juga menerima konstanta tanpa tipe 42. Hanya nilai bertipe dari tipe lain yang ditolak.
Lupa menulis tipe di baris pertama. Dalam const ( Red = iota; Green; Blue ), ketiganya adalah konstanta integer tanpa tipe, bukan nilai Color, jadi method pada Color tidak berlaku untuk mereka. Tulis Red Color = iota supaya ekspresi yang diulang membawa tipenya.
Mengubah urutan enum yang disimpan. Menyisipkan nilai di tengah blok iota diam-diam mengubah angka yang sudah tersimpan di tempat lain.
Rekursi di String. Di dalam String(), jangan pernah memformat receiver dengan %v atau %s. Konversi dulu ke tipe dasarnya.

Pertanyaan yang sering diajukan

Apakah Go punya enum?

Tidak sebagai fitur bahasa. Tidak ada kata kunci enum. Penggantinya yang idiomatis adalah tipe bernama ditambah blok konstanta bertipe, biasanya dinomori dengan iota:

type Color int

const (
	Red Color = iota
	Green
	Blue
)

Tipe itu memberimu signature yang mudah dibaca dan tempat untuk menaruh method seperti String(). Tipe itu tidak mencegah seseorang menulis Color(42), jadi validasi nilai yang datang dari luar.

Apa itu iota di Go?

iota adalah identifier bawaan yang bernilai sama dengan indeks baris saat ini (constant spec) di dalam blok const, dimulai dari 0. Nilainya kembali ke 0 di setiap blok const yang baru. Saat sebuah baris tidak menulis ekspresinya, Go mengulang ekspresi sebelumnya dengan iota berikutnya, dan itulah yang membuat Red = iota; Green; Blue menghasilkan 0, 1, 2.

Bagaimana cara membuat iota mulai dari 1?

Tulis First Kind = iota + 1 di baris pertama, atau lewati nol dengan blank identifier: _ = iota lalu First. Banyak programmer Go justru mempertahankan 0 dan menamainya Unknown atau Invalid, supaya variabel yang belum diinisialisasi (zero value-nya 0) jelas bukan pilihan yang sungguhan.

Bagaimana cara mencetak enum sebagai string di Go?

Beri tipe itu method String() string. fmt memanggilnya untuk %v, %s, dan Println, jadi fmt.Println(Green) mencetak Green, bukan 1. Kamu bisa menulis method itu secara manual dengan switch atau array, atau membuatnya otomatis dengan go run golang.org/x/tools/cmd/stringer@latest -type=Color.

Bagaimana cara mengonversi string ke enum di Go?

Tulis fungsi parse yang mencari string tersebut, biasanya di map[string]Color atau switch, dan mengembalikan error untuk input yang tidak dikenal: func ParseColor(s string) (Color, error). Mengimplementasikan UnmarshalText dengan logika yang sama membuat JSON, flag, dan loader konfigurasi memakainya secara otomatis.

Konsep terkait

Enum di Golang: Cara Membuat Enum dengan const dan iota