Golang 枚举详解

最新推荐文章于 2024-05-15 11:02:15 发布

云原生 Space

最新推荐文章于 2024-05-15 11:02:15 发布

阅读量3.1k

点赞数

文章标签： golang 后端

本文链接：https://blog.csdn.net/qq_37091832/article/details/131026781

版权

什么是枚举

枚举（Enumeration）是一种常见的编程概念，它定义了一组命名常量。我们知道在 Go 语言中定义常量是这样的形式：

const (
	A = "a"
	B = "b"
）

开发者可以使用枚举创建复杂的、有限的常量集，这些常量集具有有意义的名称和唯一的值。

枚举语法示例

在 Go 语言中，没有提供枚举类型，在 python、java、C++ 等语言中，提供了 enum 关键字来创建枚举类型。

但是 Go 语言可以利用 const + iota 实现枚举的效果，const 用来定义常量，[iota](https://github.com/golang/go/wiki/Iota) 是一个增数器，生成连续整数序列。

下面看看如何使用 const + iota 实现枚举

const (
	 Monday int = iota      // Monday  = 0
	 Tuesday               // Tuesday = 1
	 Wednesday             // Wednesday = 2
	 Thursday              // Thursday = 3
	 Friday                // Friday = 4
	 Saturday              // Saturday =5
	 Sunday                // Sunday = 6
)

可以发现 iota 生成了从 0 - 6 的整数序列分别作为常量名称的值。

枚举的使用疑问

对于刚接触枚举的，应该会有以下疑问：

枚举与常量的区别

从上面那个例子可以看出枚举好像就是定义了一堆整形常量而已。既然枚举就是定义常量，那为什么不直接使用 const 来定义常量呢？

首先看一下使用 const 来定义上面枚举实现的常量集：

const (
	 Monday     int = 0            // Monday  = 0
	 Tuesday    int = 1            // Tuesday = 1
	 Wednesday  int = 2            // Wednesday = 2
	 Thursday   int = 3            // Thursday = 3
	 Friday     int = 4            // Friday = 4
	 Saturday   int = 5            // Saturday =5
	 Sunday     int = 6            // Sunday = 6
)

可以发现使用 const 同样可以实现枚举的效果，但是没有枚举优雅。而且 const 并不能保证常量集的值是唯一的，比如 Wednesday int = 1 编译器也不会报错，但是程序可能会出现 Bug。通过使用枚举(const + iota)，编译器层面保证了常量集里不会有相同的值。

枚举值的作用

通过上面枚举示例发现枚举包括：枚举名称( Monday )、枚举类型( int )、枚举值( 0 )，枚举名称、枚举类型很好理解，枚举值在编程中的有什么作用：

枚举本身的值没有什么意义，它是用来模拟现实中的某些只能取固定值的变量的，对应一个值只是在计算机中比较好处理。

枚举值只能为整形?

在枚举示例章节看到使用 iota 生成枚举值都是整数，在 Go 语言中枚举只能使用 iota ，所以枚举值只能是整数。

下面看一个 C++ 枚举示例：

//枚举类型必须是整形吗，不能是浮点数或是别的类型?
enum E
    {
        monday=-2,
        tuesday=1.5//有么有非int类型的枚举?
    };

上面的枚举值定义为负数、浮点数，这种写法是错误的。在任何语言中，枚举值只能是整形。

枚举高级用法

从 1 开始枚举

如果不希望枚举值从 0 开始，从1 开始，可以在 Go 这样实现：

const (
	 Monday = iota + 1     // Monday  = 1
	 Tuesday               // Tuesday = 2
	 Wednesday             // Wednesday = 3
	 Thursday              // Thursday = 4
	 Friday                // Friday = 5
	 Saturday              // Saturday = 6
	 Sunday                // Sunday = 7
)

自定义枚举值

iota 默认从 0 开始且依次递增 1，同时也可以使用数学运算自定义枚举值

const (
	 Monday = iota + 1     // Monday = 0 + 1 = 1
	 Tuesday = iota + 2    // Tuesday = 1 + 2 = 3
	 Wednesday = iota * 2  // Wednesday = 2 * 2 = 2
	 Thursday              // Thursday = 3
	 Friday                // Friday = 4
	 Saturday              // Saturday =5
	 Sunday                // Sunday = 6
)

通常不建议这么做，因为容易导致枚举值混乱且重复。
那么可能会有疑问，枚举不是说保证枚举值唯一吗？在其他语言中可以保证唯一，但是 Go 语言没有 enum 关键字，只能使用 iota 来模拟枚举，如果自己使用不当也会导致枚举值重复，比如上面的例子。

跳过值的枚举

如果想要跳过某个值，可以使用 _ 字符，即忽略的意思

const (
	 Monday = iota         // Monday = 0 
   _                     // 1 被跳过
	 Tuesday               // Tuesday = 2
	 Wednesday             // Wednesday = 3
	 Thursday              // Thursday = 4
   _                     // 5 被跳过
	 Friday                // Friday = 6
	 Saturday              // Saturday = 7
	 Sunday                // Sunday = 8
)

枚举使用场景

下面举例几个枚举的使用场景，加深枚举的作用和使用。

限制参数类型

当处理状态码时，如果不使用枚举

const (
	Normal       = 200
	Forbid       = 403
	NetworkError = 502
)

// 该函数形参是整形
func HandlerStatus(statusCode int) {
	fmt.Println(statusCode)
}

// 调用 HandlerStatus 随便什么整数都可以
func main() {
	HandlerStatus(Normal)
	HandlerStatus(404)
}

结果：
200
404

HandlerStatus 这个函数应该只能传 Normal、 Forbid、NetworkError 这三个常量，可以发现常量集之外的值也可以被正常调用，会使得程序不严谨。

下面看看使用枚举是否能达到效果？

虽然 Go 中并没有 enum 关键字来定义枚举类型，但是 Go 使用类型别名来定义枚举类型

// int 别名
type Code int

const (
	Normal Code = iota
	Forbid
	NetworkError
)

func HandlerStatus(statusCode Code) {
	fmt.Println(statusCode)
}

func main() {
	HandlerStatus(Normal)
	var notFount int = 1
	// 这里会导致程序编译失败，因为 notFount 不是 Code 类型
	HandlerStatus(notFount)
}

通过枚举就可以限制 HandlerStatus 的入参类型，保证程序的严谨。

使用 string 作为枚举值

我们知道 Go 语言使用 iota 生成连续整数作为枚举值，但是有的时候希望能描述枚举常量的意思，这个时候除了看枚举常量名称，也可以将枚举值转成 string 来达到效果。下面通过例子看看：

// 声明一个 week 类型
type week int

const (
	 Monday week = iota    // Monday  = 0
	 Tuesday               // Tuesday = 1
	 Wednesday             // Wednesday = 2
	 Thursday              // Thursday = 3
	 Friday                // Friday = 4
	 Saturday              // Saturday =5
	 Sunday                // Sunday = 6
)

func main() {
	var w week = Monday
	switch w {
	case Monday:
		fmt.Println(Monday)
	case Tuesday:
		fmt.Println(Tuesday)
	}
}

输出结果：
0

可以发现直接打印出了该枚举常量的枚举值 0，但是 0 并不是很容易理解该枚举常量的意义。

下面借助 Go 中 String 方法的默认约定，针对于定义了 String 方法的类型，默认输出的时候会调用该方法。

// 声明一个 week 类型
type week int

const (
	 Monday week = iota    // Monday  = 0
	 Tuesday               // Tuesday = 1
	 Wednesday             // Wednesday = 2
	 Thursday              // Thursday = 3
	 Friday                // Friday = 4
	 Saturday              // Saturday =5
	 Sunday                // Sunday = 6
)

// 实现 week 类型的 String() 方法
func (w week) String() string {
		return [...]string{"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"}[w]
}

func main() {
	var w week = Monday
	switch w {
	case Monday:
		fmt.Println(Monday)
	case Tuesday:
		fmt.Println(Tuesday)
	}
}

输出结果：
星期一