[!info] related notes

• 所属 MOC: Go 语言基础 MOC
• 前置概念: Go 基本类型, [[go-constants|Go 常量]]
• 并列概念: Go 闭包

Go iota 与枚举

一句话定义

iota 是 Go const 块中的自增计数器，从 0 开始，每行递增 1，配合自定义命名类型可构建类型安全的枚举。

核心机制 / 工作原理

1. iota 基本规则：

   • 只在 const 块内有效，块外无意义。
   • 从 0 开始，每个 const 声明行（不是每个常量）递增 1。
   • 如果一行有多个常量，它们共享同一个 iota 值。
   • 可参与表达式运算：iota << 1、1 << iota 等。

2. Go 没有 enum 关键字：枚举是一种约定模式，而非语言内置类型。核心手段是：自定义命名类型 + iota 生成常量 + String() 方法。

3. 类型安全：type Color int 创建了新类型，Color(0) 和 int(0) 是不同类型。将枚举定义为自定义类型后，函数签名 func Paint(c Color) 可以在编译期阻止传入任意 int。

4. //go:generate 与枚举工具：社区工具如 stringer 可以自动为枚举类型生成 String() 方法，避免手写。

5. 位掩码（bitmask）模式：利用 1 << iota 生成标志位，通过 | 组合，& 检测：

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

6. 跳过值：使用 _ 占位跳过某个 iota 值。也可以用 iota + N 手动偏移起始值。

最小例子 / 最小场景

package main

import "fmt"

// 基本枚举
type Color int

const (
    Red    Color = iota // 0
    Green               // 1
    Blue                // 2
)

// 实现 Stringer 接口
func (c Color) String() string {
    names := [...]string{"Red", "Green", "Blue"}
    if c < 0 || int(c) >= len(names) {
        return fmt.Sprintf("Color(%d)", c)
    }
    return names[c]
}

// 位掩码枚举
type Permission uint8

const (
    PermRead    Permission = 1 << iota // 0b001 = 1
    PermWrite                          // 0b010 = 2
    PermExecute                        // 0b100 = 4
)

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

// 跳过值 + 偏移
type HTTPStatus int

const (
    StatusOK            HTTPStatus = iota + 200 // 200
    StatusCreated                                // 201
    StatusAccepted                               // 202
    _                                            // 跳过 203
    StatusNoContent                              // 204
)

func main() {
    // 基本枚举
    c := Red
    fmt.Println(c)        // Red
    fmt.Println(c == Red) // true

    // 位掩码
    perm := PermRead | PermWrite
    fmt.Println(perm.Has(PermRead))    // true
    fmt.Println(perm.Has(PermExecute)) // false

    // HTTP 状态码
    fmt.Println(StatusOK)       // 跳过前缀输出: 200
    fmt.Println(StatusNoContent) // 204
}

为什么重要

• Go 的惯用枚举模式：几乎所有 Go 项目都会用到 iota 枚举——状态机、配置选项、错误码、权限标志、类型标识等。
• 编译期类型安全：自定义类型 + iota 比裸 int 常量更安全。func SetState(s State) 而非 func SetState(s int)，编译器帮你拦住错误。
• 位掩码高效表示组合标志：网络权限、文件权限、特性开关——一个 uint8 就能表示 8 个独立标志的任意组合，比 bool 字段或 map 紧凑得多。
• 与其他语言的对比：Go 的枚举比 Java/Kotlin 的 enum class 轻量（无运行时对象），比 C 的 enum 类型安全（有命名类型），比 Python 的 Enum 性能更好（编译期常量）。

边界与易混淆点

• iota 不是关键字，只是 const 块内的特殊标识符：在 const 块外使用 iota 会编译报错，但它不是保留字，可以在变量名中出现（不建议）。
• 枚举值默认可以与整数隐式比较：Color(1) == 1 是合法的（Go 中自定义底层类型的值可以与同底层类型的值比较）。类型安全是”半透明”的。
• 没有 exhaustive switch 检查：Go 的 switch 不会检查是否覆盖了所有枚举值。遗漏 case 不会编译报错，可以考虑 golang.org/x/tools/go/analysis/passes/printf 或 exhaustive linter。
• String() 不是自动生成的：必须手写或用 go generate 工具生成。忘记实现会导致 fmt.Println 输出数字而非名称。
• iota + 表达式的行数敏感：const 块中插入或删除一行会影响后续所有 iota 值。建议用显式赋值 Red Color = 0 而非依赖 iota 的场景，考虑值的稳定性需求（如持久化到数据库或文件时，数值不能因代码变动而改变）。