Go 语言可用 iota 搭配自定义类型、方法和结构体模拟语义清晰、行为丰富、类型安全的枚举：通过 iota 定义具名常量，为类型添加 String() 等方法实现行为，用 map 或 struct 关联字段，结合包级封装防止非法构造。
Go 语言没有原生的枚举类（如 Java/Kotlin 那样支持字段、方法、构造逻辑的 enum），但可以用 iota 搭配自定义类型、方法和封装结构，模拟出**语义清晰、行为丰富、类型安全**的枚举效果。关键不在于“完全复刻”，而在于用 Go 的惯用法达成类似目标：可读性强、不可非法构造、能携带行为。
基础：用 iota 定义枚举值
先定义一个整数类型，并用 iota 赋值，这是最常见也最安全的起点：
type Status int
const (
StatusPending Status = iota // 0
StatusRunning // 1
StatusSuccess // 2
StatusFailed // 3
)
这样定义后，Status 是独立类型，不能和普通 int 混用，具备基本类型安全。但还只是“值”，没有“行为”——接下来加方法。
为枚举类型添加方法（类似 Kotlin 的 enum method）
直接在 Status 类型上定义方法即可，Go 支持为自定义类型添加任意方法：
func (s Status) String() string {
names := map[Status]string{
StatusPending: "pending",
StatusRunning: "running",
StatusSuccess: "success",
StatusFailed: "failed",
}
if name, ok := names[s]; ok {
return name
}
return "unknown"
}
func (s Status) IsTerminal() bool {
return s == StatusSuccess || s == StatusFailed
}
func (s Status) CanRetry() bool {
return s == StatusFailed
}
调用示例：
fmt.Println(StatusRunning.String()) // "running" fmt.Println(StatusSuccess.IsTerminal()) // true fmt.Println(StatusPending.CanRetry()) // false
✅ 这就实现了“每个枚举实例自带方法”的效果，且无运行时反射开销，性能好、IDE 可跳转、类型检查严格。
进阶：带字段的枚举（模拟 Java enum 构造器）
如果需要每个枚举值关联不同数据（比如 HTTP 状态码 + 短消息），可以结合结构体和私有构造函数来模拟：
type HttpStatus struct {
Code int
Text string
}
type HttpStatusCode int
const (
HTTPContinue HttpStatusCode = iota // 0
HTTPSwitchingProtocols // 1
HTTPProcessing // 2
// ... 更多值
)
var httpStatusMap = map[HttpStatusCode]HttpStatus{
HTTPContinue: {100, "Continue"},
HTTPSwitchingProtocols: {101, "Switching Protocols"},
HTTPProcessing: {102, "Processing"},
}
func (h HttpStatusCode) Status() HttpStatus {
if s, ok := httpStatusMap[h]; ok {
return s
}
return HttpStatus{0, "Unknown"}
}
func (h HttpStatusCode) Code() int { return h.Status().Code }
func (h HttpStatusCode) Text() string { return h.Status().Text }
这样每个枚举值隐式绑定一组字段，调用 HTTPContinue.Code() 就拿到 100，本质是查表+封装，简洁可控。
防误用：禁止外部构造（强化枚举语义）
避免用户写 Status(999) 创建非法值，可在包内加校验或使用“未导出字段+工厂函数”模式：
- 方式一（推荐）：文档 + 单元测试约束，配合
String()返回空字符串或 panic 处理非法值 - 方式二：用结构体封装，只暴露常量和
方法，不暴露底层 int
type Level struct {
level int
}
var (
Debug = Level{0}
Info = Level{1}
Warning = Level{2}
Error = Level{3}
)
func (l Level) String() string {
names := [...]string{"debug", "info", "warning", "error"}
if l.level < 0 || int(l.level) >= len(names) {
return "invalid"
}
return names[l.level]
}
这种写法彻底隐藏了整数表示，更接近 Kotlin 的 object enum 实例，但失去 iota 的自动递增便利——按需选择。
不复杂但容易忽略：真正让 Go 枚举“像 Java/Kotlin”的，不是语法糖，而是**把值、行为、校验、文档打包成一个自包含类型**。用 iota 起步，用方法承载逻辑，用 map 或 struct 关联数据，用包级约束保障安全——这就是 Go 式的优雅枚举。
