Không, enum không phải một tính năng của ngôn ngữ. Go không có từ khóa enum. Cách thay thế chuẩn mực là một kiểu có tên cùng một khối hằng số có kiểu, thường được đánh số bằng iota: Kiểu này giúp chữ ký hàm dễ đọc và là nơi để gắn các phương thức như String(). Nó không ngăn ai đó viết Color(42), vì vậy hãy kiểm tra các giá trị đến từ bên ngoài.

Tài liệu Go chạy trực tiếp: Enum và iota

Q: iota trong Go là gì?

iota là một định danh khai báo sẵn, có giá trị bằng chỉ số của dòng hiện tại (constant spec) trong khối const, bắt đầu từ 0. Nó đặt lại về 0 trong mỗi khối const mới. Khi một dòng bỏ trống biểu thức, Go lặp lại biểu thức của dòng trước với giá trị iota tiếp theo, nhờ vậy Red = iota; Green; Blue cho ra 0, 1, 2.

Q: Làm sao để iota bắt đầu từ 1?

Viết First Kind = iota + 1 ở dòng đầu tiên, hoặc bỏ qua số 0 bằng định danh trống: _ = iota rồi đến First. Nhiều lập trình viên Go lại giữ số 0 và đặt tên là Unknown hoặc Invalid, để một biến chưa khởi tạo (có giá trị zero là 0) rõ ràng không phải một lựa chọn thật.

Q: Làm sao in enum ra dạng chuỗi trong Go?

Thêm cho kiểu một phương thức String() string. fmt gọi phương thức này với %v, %s và Println, nên fmt.Println(Green) in ra Green thay vì 1. Bạn có thể tự viết phương thức bằng switch hoặc một mảng, hoặc sinh tự động bằng go run golang.org/x/tools/cmd/stringer@latest -type=Color.

Q: Làm sao chuyển chuỗi thành enum trong Go?

Viết một hàm phân tích tra cứu chuỗi, thường trong một map[string]Color hoặc một switch, và trả về lỗi khi gặp đầu vào lạ: func ParseColor(s string) (Color, error). Cài đặt UnmarshalText với cùng logic đó thì JSON, flag và các trình tải cấu hình sẽ tự động dùng nó.

Go không có từ khóa enum. Bạn tạo một enum từ hai thành phần: một kiểu có tên, và một khối const gồm các giá trị thuộc kiểu đó, được đánh số bằng 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 bằng 0, và mỗi dòng sau lớn hơn một đơn vị. Chính kiểu có tên Weekday biến danh sách này thành một enum thay vì một dãy số: chữ ký của isWeekend cho biết hàm cần gì, và bạn có thể thêm phương thức cho kiểu. Đầu ra in 1 5 6 vì chưa có gì cho Go biết cách hiển thị một Weekday dưới dạng văn bản. Phần đó có ở bên dưới.

Cách iota hoạt động

iota là một bộ đếm do trình biên dịch cung cấp bên trong khối const. Hai quy tắc giải thích mọi mẹo dựa trên nó:

iota bằng chỉ số của dòng hiện tại trong khối, bắt đầu từ 0, và đặt lại về 0 trong mỗi khối const mới.
Một dòng không có = expression sẽ lặp lại biểu thức và kiểu của dòng trước, được tính với giá trị iota mới.

Vì vậy Monday ở trên là cách viết tắt của Monday Weekday = iota, với iota lúc này bằng 1. Vì biểu thức được lặp lại, nó có thể là bất kỳ biểu thức hằng nào, không chỉ riêng 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 đếm dòng, không đếm tên: hai hằng số trên cùng một dòng dùng chung một giá trị iota, như X và Y cho thấy.

Bắt đầu từ 1, và lý do có thể không nên

Một biến kiểu enum chưa được gán sẽ mang giá trị 0, tức giá trị zero của nó. Nếu 0 là một giá trị thật như Sunday, bạn không phân biệt được "người dùng đã chọn Chủ Nhật" với "trường này chưa bao giờ được điền". Có ba cách khắc phục phổ biến:

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

Cách 1 phổ biến nhất trong code production, và các enum Go sinh từ protobuf cũng theo cách này (..._UNSPECIFIED = 0). Khi đó giá trị zero mang một ý nghĩa trung thực.

Bỏ qua giá trị

Định danh trống _ dùng hết một giá trị iota mà không tạo tên nào. Dùng nó để chừa khoảng trống, chẳng hạn để khớp với các số do một giao thức quy định hoặc để bỏ một giá trị mà không phải đánh số lại phần còn lại:

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
)

Khi các con số đã được một đặc tả bên ngoài cố định, như các opcode WebSocket này, viết rõ từng số (OpClose Opcode = 8) thường dễ hiểu hơn việc đếm các chỗ trống. iota dành cho những giá trị mà bạn không quan tâm đến con số chính xác.

Không bao giờ sắp xếp lại hay chèn thêm vào một danh sách iota có các con số đã được lưu trong cơ sở dữ liệu, trong tệp hoặc gửi qua mạng. Thêm một dòng ở giữa sẽ dịch chuyển mọi giá trị phía sau. Hãy thêm giá trị mới vào cuối, hoặc gán số một cách tường minh.

Thêm phương thức String

Thêm cho kiểu một phương thức String() string và fmt sẽ dùng nó cho %v, %s và 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)
}

Có hai chi tiết quan trọng trong phương thức đó:

Phần kiểm tra giới hạn. Thiếu nó, Weekday(9).String() sẽ panic vì chỉ số vượt phạm vi, và sớm muộn chuyện đó cũng xảy ra, vì không có gì ngăn người gọi tạo ra Weekday(9).
int(d) bên trong Sprintf. Định dạng chính d bằng %d thì không sao, nhưng định dạng nó bằng %v sẽ gọi lại String() và đệ quy cho đến khi tràn stack.

%d vẫn in ra con số, nên bạn có cả hai dạng: Wednesday is day 3.

Sinh String bằng stringer

Với danh sách dài, công cụ stringer sẽ viết phương thức thay bạn:

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

go generate ./...

Công cụ tạo ra weekday_string.go với một bản cài đặt String() gọn gàng, kèm một phép kiểm tra lúc biên dịch làm build thất bại nếu các hằng số thay đổi mà chưa sinh lại. Cờ -linecomment dùng chú thích cuối dòng làm tên, rất tiện cho những tên có dấu cách.

Kiểm tra giá trị hợp lệ

Enum trong Go không đóng. Mọi giá trị thuộc kiểu nền đều chuyển được sang nó, và hằng số không kiểu được chuyển ngầm định:

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

Vì vậy hãy kiểm tra các giá trị đến từ bên ngoài code của bạn (JSON, cơ sở dữ liệu, flag, package khác):

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

Hằng canh gác không export colorCount ở cuối khối giúp IsValid luôn đúng khi bạn thêm màu mới, vì nó luôn đứng sau giá trị thật cuối cùng một đơn vị.

Dùng switch với enum

Enum thường được xử lý bằng switch. Go không kiểm tra xem một switch có bao hết mọi giá trị hay không, vì vậy hãy thêm default để báo trường hợp bất ngờ:

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

Linter bên thứ ba exhaustive (có trong golangci-lint) báo các switch trên kiểu enum bị thiếu case, giúp bạn có gần như đầy đủ những gì phép kiểm tra enum toàn diện mang lại ở các ngôn ngữ khác.

Enum dạng bit flag

Khi các giá trị có thể kết hợp với nhau, như quyền truy cập, hãy dùng mỗi giá trị một bit với 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)
}

| kết hợp các flag, & kiểm tra chúng, và &^ (toán tử AND NOT của Go) xóa chúng. Kiểu nền không dấu là lựa chọn phù hợp ở đây: uint8 chứa được 8 flag, uint64 chứa được 64.

Enum dạng chuỗi

Khi giá trị vốn được lưu hoặc gửi dưới dạng văn bản, một kiểu dựa trên chuỗi giúp bỏ đi lớp chuyển đổi:

type Env string

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

Giá trị được in và tuần tự hóa dễ đọc mà không cần phương thức String(), và một cột trong cơ sở dữ liệu chứa "prod" thay vì một con số phụ thuộc vào thứ tự khai báo. Đổi lại: phép so sánh là so sánh chuỗi, không thể dùng bit flag, và việc kiểm tra hợp lệ vẫn là của bạn, vì Env("banana") cũng biên dịch được.

Enum và JSON

Theo mặc định, một enum số nguyên được tuần tự hóa thành số. Để đọc và ghi bằng tên, hãy cài đặt encoding.TextMarshaler và encoding.TextUnmarshaler. encoding/json dùng chúng cho giá trị và cho khóa của 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 có receiver kiểu giá trị nên hoạt động với cả Level lẫn *Level; UnmarshalText cần receiver con trỏ vì nó thay đổi giá trị. Cũng hai phương thức đó giúp kiểu hoạt động với TextVar của package flag và với hầu hết thư viện cấu hình.

Những lỗi thường gặp

Chuyển đổi ngầm định của literal. Một hàm nhận Weekday cũng chấp nhận hằng số không kiểu 42. Chỉ những giá trị có kiểu khác mới bị từ chối.
Quên khai báo kiểu ở dòng đầu. Trong const ( Red = iota; Green; Blue ) cả ba đều là hằng số nguyên không kiểu, không phải giá trị Color, nên các phương thức của Color không áp dụng cho chúng. Hãy viết Red Color = iota để biểu thức được lặp lại mang theo kiểu.
Sắp xếp lại enum đã được lưu. Chèn một giá trị vào giữa khối iota sẽ âm thầm làm thay đổi các con số đã lưu ở nơi khác.
Đệ quy trong String. Bên trong String(), đừng bao giờ định dạng receiver bằng %v hoặc %s. Hãy chuyển sang kiểu nền trước.

Câu hỏi thường gặp

Go có enum không?

Không, enum không phải một tính năng của ngôn ngữ. Go không có từ khóa enum. Cách thay thế chuẩn mực là một kiểu có tên cùng một khối hằng số có kiểu, thường được đánh số bằng iota:

type Color int

const (
	Red Color = iota
	Green
	Blue
)

Kiểu này giúp chữ ký hàm dễ đọc và là nơi để gắn các phương thức như String(). Nó không ngăn ai đó viết Color(42), vì vậy hãy kiểm tra các giá trị đến từ bên ngoài.

iota trong Go là gì?

iota là một định danh khai báo sẵn, có giá trị bằng chỉ số của dòng hiện tại (constant spec) trong khối const, bắt đầu từ 0. Nó đặt lại về 0 trong mỗi khối const mới. Khi một dòng bỏ trống biểu thức, Go lặp lại biểu thức của dòng trước với giá trị iota tiếp theo, nhờ vậy Red = iota; Green; Blue cho ra 0, 1, 2.

Làm sao để iota bắt đầu từ 1?

Viết First Kind = iota + 1 ở dòng đầu tiên, hoặc bỏ qua số 0 bằng định danh trống: _ = iota rồi đến First. Nhiều lập trình viên Go lại giữ số 0 và đặt tên là Unknown hoặc Invalid, để một biến chưa khởi tạo (có giá trị zero là 0) rõ ràng không phải một lựa chọn thật.

Làm sao in enum ra dạng chuỗi trong Go?

Thêm cho kiểu một phương thức String() string. fmt gọi phương thức này với %v, %s và Println, nên fmt.Println(Green) in ra Green thay vì 1. Bạn có thể tự viết phương thức bằng switch hoặc một mảng, hoặc sinh tự động bằng go run golang.org/x/tools/cmd/stringer@latest -type=Color.

Làm sao chuyển chuỗi thành enum trong Go?

Viết một hàm phân tích tra cứu chuỗi, thường trong một map[string]Color hoặc một switch, và trả về lỗi khi gặp đầu vào lạ: func ParseColor(s string) (Color, error). Cài đặt UnmarshalText với cùng logic đó thì JSON, flag và các trình tải cấu hình sẽ tự động dùng nó.

Khái niệm liên quan

Enum trong Golang: cách tạo enum với const và iota