Go 枚举(enum)

在实际开发中,有些数据的取值只可能是固定有限的几种情况。比如一周只有星期一到星期日 7 天,订单状态通常只有 “待支付”、“已支付”、“已发货” 和 “已取消” 这 4 种。

在编程中,把一个类型所有可能的取值逐一列举出来,就叫做 “枚举(enum)”。其中,“enum” 是英文单词 “enumeration(列举、枚举)” 的缩写。Go 语言没有提供专门的 enum 关键字,我们通常将自定义类型与 const 常量块结合起来实现枚举。

定义 Go 枚举

如果只使用普通的 int 常量来表示订单状态,把函数形参写成 status int,那么调用函数时就算不小心传进一个年龄变量,编译器也不会报错:

func checkOrder(status int) {
    // 函数体
}

age := 20
checkOrder(age)    // 误传入年龄变量也不会报错

为了让编译器帮我们严格区分不同的状态类型,我们可以先使用 type 定义一个专属的自定义类型,再在 const 块中配合 iota 常量计数器列举该类型的所有常量值。

语法:

type 枚举类型名 int

const (
    枚举值1 枚举类型名 = iota
    枚举值2
    枚举值3
)

说明:

在定义 Go 枚举时,我们需要掌握以下 2 条规则:

  • 自动沿用类型与递增:在 const 小括号块中,我们只需要为第 1 个常量显式写出 枚举类型名 = iota。后面的常量省略类型和赋值后,不仅数值会按行自动加 1,还会自动沿用相同的枚举类型。
  • 统一添加名称前缀:同一组枚举常量建议加上统一的前缀,比如订单状态统一以 Status 开头。这样同一个包内定义多组枚举时不会重名,输入前缀时编辑器也会自动弹出补全提示。

示例 1:定义订单状态枚举

package main

import "fmt"

// 定义订单状态类型
type OrderStatus int

// 列举订单状态常量
const (
    StatusPending   OrderStatus = iota    // 待支付:0
    StatusPaid                            // 已支付:1
    StatusShipped                         // 已发货:2
    StatusCancelled                       // 已取消:3
)

func checkOrder(s OrderStatus) {
    fmt.Printf("状态值:%d,类型:%T\n", s, s)
}

func main() {
    checkOrder(StatusPaid)
    checkOrder(StatusShipped)
}

运行结果如下。

状态值:1,类型:main.OrderStatus
状态值:2,类型:main.OrderStatus

分析:

在这个例子中,type OrderStatus int 定义了一个底层为 int 的新类型。随后的 const 块中,StatusPending 的值为 0,后面的常量会自动沿用 OrderStatus 类型,数值依次递增为 1、2、3。

将 checkOrder() 函数的形参声明为 OrderStatus 类型后,编译器就会严格检查传入的变量类型。下面这 2 种调用写法中,第 2 种会直接触发编译报错。

// 正确方式
checkOrder(StatusPaid)

// 错误方式
code := 999
checkOrder(code)

在上面的错误方式中,code 是普通的 int 变量。直接执行 checkOrder(code) 会触发编译报错 cannot use code as OrderStatus value,提示不能把 int 变量当作 OrderStatus 传入。

注意: 如果在调用时直接手写数字字面量(如 checkOrder(999)),编译阶段不会报错。就像之前写 var f float64 = 10 时纯数字 10 没有固定类型、会自动适配目标类型一样,手写数字传参时也会自动转换成 OrderStatus。因此平时传参时,小伙伴们都应该传入定义好的枚举常量名(如 StatusPaid),不要直接手写数字。

枚举的默认零值处理

在实际项目开发中,枚举经常作为结构体的一个字段来使用。如果创建结构体变量时没有给枚举字段赋初值,该字段会自动取整数的默认零值 0。

这就会带来一个容易忽略的隐患:如果像示例 1 那样把数字 0 分配给 StatusPending(待支付),新声明一个空的订单结构体时,它的状态默认就是 0。这样程序就会把还没设置状态的空订单,误当成一笔正常的 “待支付” 订单。

为了区分 “尚未设置状态” 和 “正常业务状态”,我们在定义枚举时通常会把第 1 个值 0 预留给表示 “未知” 的占位常量(如 StatusUnknown),让真正的业务状态从 1 开始编号。

示例 2:预留未知零值状态

package main

import "fmt"

type OrderStatus int

const (
    StatusUnknown OrderStatus = iota    // 未知状态:0
    StatusPending                       // 待支付:1
    StatusPaid                          // 已支付:2
    StatusShipped                       // 已发货:3
)

type Order struct {
    ID     int
    Status OrderStatus
}

func main() {
    ord := Order{ID: 1001}
    fmt.Println(ord.Status == StatusUnknown)
    fmt.Println(ord.Status == StatusPending)
}

运行结果如下。

true
false

分析:

创建订单变量 ord 时,我们只填写了 ID 字段,未指定的 Status 字段会自动取默认零值 0,正好对应 StatusUnknown。

因此判断 ord.Status == StatusUnknown 会返回 true,而 ord.Status == StatusPending 返回 false,不会再把未赋值的空订单误判为 “待支付”。

如果业务中不需要单独定义 StatusUnknown 常量,我们也可以在 const 块的第 1 行使用下划线 _ 跳过 0,或者写成 iota + 1 直接从 1 开始计数。对于这个需求来说,下面 2 种方式是等价的。

// 方式 1
const (
    _ OrderStatus = iota
    StatusPending
    StatusPaid
)

// 方式 2
const (
    StatusPending OrderStatus = iota + 1
    StatusPaid
)

上面这两种写法都能让 StatusPending 从 1 开始编号,避免结构体的默认零值与正常业务状态混淆。

为枚举绑定 String() 方法

由于 OrderStatus 底层存的是整数,直接调用 fmt.Println(StatusPaid) 打印时,屏幕上只会输出数字 2。当枚举项变多以后,光看日志里的数字 1、2、3,很难直观看出每个数字代表什么状态。

为了让枚举直接输出对应的文字名称,我们可以结合前面学过的方法,为枚举类型绑定一个固定名为 String() 的方法。

语法:

func (接收者变量 枚举类型名) String() string {
    // 方法体
}

说明:

这里的方法名必须写成首字母大写的 String,不接收任何参数,返回值固定为 string 类型。在方法体内部,我们通常配合 switch 语句返回各个枚举常量对应的名称。

只要某个自定义类型绑定了 String() string 方法,当我们使用 fmt.Println()、%v 或 %s 打印该类型的变量时,fmt 包就会自动调用这个方法并输出对应的文本。

示例 3:输出枚举的中文名称

package main

import "fmt"

type OrderStatus int

const (
    StatusUnknown OrderStatus = iota
    StatusPending
    StatusPaid
    StatusShipped
)

func (s OrderStatus) String() string {
    switch s {
    case StatusPending:
        return "待支付"
    case StatusPaid:
        return "已支付"
    case StatusShipped:
        return "已发货"
    default:
        return "未知状态"
    }
}

func main() {
    status := StatusPaid
    fmt.Println(status)
    fmt.Printf("当前状态:%s\n", status)
    fmt.Println(int(status))
}

运行结果如下。

已支付
当前状态:已支付
2

分析:

func (s OrderStatus) String() string 表示为 OrderStatus 绑定专属的字符串转换方法。调用 fmt.Println(status) 或配合 %s 格式化输出时,屏幕不再显示数字 2,而是直接输出清晰的 "已支付"。

如果我们在后续计算或调试中需要查看它底层的整数编号,由于 OrderStatus 底层本身就是 int,可以直接通过 int(status) 显式转回普通整数。此时打印出来的就是数字 2。

提示: 为枚举绑定 String() 方法时,我们推荐使用值接收者而不是指针接收者。这样不管是打印普通的枚举变量,还是打印枚举指针,都能自动触发 String() 方法输出对应的名称。

字符串枚举与合法性校验

除了基于 int 配合 iota 定义整数枚举之外,在开发前后端交互接口时,我们还经常基于 string 类型定义字符串枚举,比如表示用户角色的 "admin"、"user" 和 "guest"。

字符串枚举不需要使用 iota,也不需要额外编写 String() 方法,直接打印或转成 JSON 数据时本身就是直观易读的单词。同时,我们还可以为枚举绑定一个 IsValid() 方法,用来检查外部传入的值是否属于合法的枚举项。

示例 4:定义字符串枚举并校验

package main

import "fmt"

type Role string

const (
    RoleAdmin Role = "admin"
    RoleUser  Role = "user"
    RoleGuest Role = "guest"
)

// 判断是否为合法的角色枚举值
func (r Role) IsValid() bool {
    switch r {
    case RoleAdmin, RoleUser, RoleGuest:
        return true
    default:
        return false
    }
}

func main() {
    r1 := RoleAdmin
    r2 := Role("vip")

    fmt.Println(r1, r1.IsValid())
    fmt.Println(r2, r2.IsValid())
}

运行结果如下。

admin true
vip false

分析:

在上面代码中,Role 是基于 string 定义的自定义类型,每个枚举常量直接赋为清晰的字符串。

当程序从外部接口读取到一个字符串并通过 Role("vip") 转换时,编译阶段无法预知具体内容。此时我们调用 r2.IsValid(),就能通过 switch 判断它是否在合法范围内,遇到未定义的角色会返回 false 以便及时处理。

在实际开发中,如果枚举值只在程序内部流转,或者数据库存的就是数字状态码,小伙伴们优先选择占用空间小、比较速度快的 int 枚举即可。如果枚举值需要频繁通过 JSON 接口发给前端展示,使用直观易读的 string 枚举会省事不少。

常见问题

1. 如果一个枚举包含几十个常量,也要手动写很长的 switch 来返回名称吗?

日常业务中的枚举通常只有三五个或十来个取值,我们直接手写一个 switch 方法非常简单直观,后续修改中文提示文字也很方便。

如果遇到包含几十个常量的底层枚举,Go 官方提供了名为 stringer 的命令行工具,可以根据常量名自动生成 String() 方法代码。对于初学阶段和绝大多数日常开发来说,小伙伴们直接手写 switch 就足够了。

2. 为什么绑定了 String() 方法后,fmt.Println() 就能自动识别并调用它?

这是因为 Go 标准库的 fmt 包内部定义了一个 Stringer 接口,任何绑定了 String() string 方法的类型都会自动满足这个接口的要求。

当 fmt.Println() 打印变量时,只要发现该变量满足这个要求,就会自动调用它的 String() 方法获取文本。具体原理我们在下一章学习接口时会详细介绍。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号