Golang 如何表示枚举类型

go 语言枚举类型是这么用的？在什么场景下会用到枚举？本文对 go 语言枚举做了详细讲解。

枚举，是一种重要的数据类型，由一组键值对组成，通常用来在编程语言中充当常量的标识符。在主流行编程语言如 c、 java 等，都有原生支持。在 go 中，大家却找不到 enum 或者其它直接用来声明枚举类型的关键字。从熟悉其它编程语言的开发者转用 go 编程，刚开始会比较难接受这种情况。其实，如果你看到如何在 go 中表示枚举类型时，可能会感受到 go 语言设计者对简洁性、问题考虑的深度，是一般资浅工程师无法比拟的。

其实，在 go 语言设计者的眼里，enum 本质是常量，为什么要多余一个关键字呢？在 go 只是没有 enum 关键字而已，其表现枚举的形式，与其它语言别无太大区别。下面来看看如果在 go 中表示枚举。

学习、使用一门语言，是学习、理解语言本身的设计哲学，同时也会感受到设计者的性格特点。

基础工作 

为了下面讲解方便，这里使用 go modules 的方式先建立一个简单工程。

1. ~/Projects/go/examples  
2. ➜  mkdir enum  
3. ~/Projects/go/examples  
4. ➜  cd enum  
5. ~/Projects/go/examples/enum  
6. ➜  go mod init enum  
7. go: creating new go.mod: module enum  
8. ~/Projects/go/examples/enum  
9. ➜  touch enum.go 

const + iota

以 启动、运行中、停止 这三个状态为例，使用 const 关键来声明一系列的常量值。在 enum.go 中写上以下内容：

1. package main  
2. import "fmt"  
3. const (  
4.     Running int = iota  
5.     Pending  
6.     Stopped  
7. )  
8. func main() {  
9.     fmt.Println("State running: ", Running)  
10.     fmt.Println("State pending: ", Pending)  
11.     fmt.Println("State Stoped: ", Stopped)  
12. } 

保存并运行，可以得到以下结果，

1. ~/Projects/go/examples/enum   
2. ➜  go run enum.go  
3. State running:  0  
4. State pending:  1  
5. State Stoped:  2 

在说明发生了什么之前，我们先看来一件东西，iota。相比于 c、java，go 中提供了一个常量计数器，iota，它使用在声明常量时为常量连续赋值。

比如这个例子，

1. const (  
2.     a int = iota // a = 0  
3.     b int = iota // b = 1  
4.     c int = iota // c = 2  
5. )  
6. const d int = iota // d = 0 

在一个 const 声明块中，iota 的初始值为 0，每声明一个变量，自增 1。以上的代码可以简化成：

1. const (  
2.     a int = iota // a = 0  
3.     b // b = 1  
4.     c // c = 2  
5. )  
6. const d int = iota // d = 0 

设想一下，如果此时有 50 或者 100 个常量数，在 c 和 java 语言中写出来会是什么情况。

关于 iota，有更多的具体的技巧（例如跳数），详细请看官方定义 iota。

通过使用 const 来定义一连串的常量，并借助 iota 常量计数器，来快速的为数值类型的常量连续赋值，非常方便。虽然没有了 enum 关键字，在这种情况下发现，是多余的，枚举本质上就是常量的组合。

当然，你可以使用以下方式，来更接近其它语言的 enum，

1. // enum.go  
2. ...  
3. type State int  
4. const (  
5.     Running State = iota  
6.     Pending  
7.     Stopped  
8. )  
9. ... 

把一组常量值，使用一个类型别名包裹起来，是不是更像其它语言中的 enum {} 定义了呢？

你还可以将上面的例子改为：

1. // enum.go  
2. ...  
3. type State int 
4. const (  
5.     Running State = iota  
6.     Pending  
7.     Stopped  
8. )  
9. func (s State) String() string {  
10.     switch s {  
11.     case Running:  
12.         return "Running"  
13.     case Pending:  
14.         return "Pending"  
15.     case Stopped:  
16.         return "Stopped"  
17.     default:  
18.         return "Unknown" 
19.      }  
20. }  
21. ... 

为定义的枚举类型加上 String 函数，运行结果如下：

1. ~/Projects/go/examples/enum   
2. ➜  go run enum.go  
3. State running:  Running  
4. State pending:  Pending  
5. State Stoped:  Stopped 

是不是很魔幻，思路一下又开阔一些，长见识了。把实际的值与打印字符分开，一般语言设计者不会想到。看到这里，有没有这种的感觉，go 语言的设计者并不是偷懒，而是为了可以偷懒想了很多、做了很多。

原文地址:https://mp.weixin.qq.com/s/Q8kbShfV0oCMMPxNA9EVBw