三分钟带你用 Go 语言实现枚举

开发 前端
Go语言是没有 enum 这个枚举关键字的。那 Go 语言里面又是怎么处理枚举这个问题的呢?我们这篇文章讲解下!

本文转载自微信公众号「GoLang全栈」,作者小锟哥哥。转载本文请联系GoLang全栈公众号。

Go语言是没有 enum 这个枚举关键字的。

那 Go 语言里面又是怎么处理枚举这个问题的呢?

我们这篇文章讲解下!

需要枚举的场景

我们在处理人的姓名的时候,一般都是男或者女,或者最大再加一个未知,不会有其他类型吧。

像上面这种常见,我们一般就会使用枚举处理。

我们会定义一个变量,希望他能只能赋 男、女、未知 这三种值。

如果是在其他语言:

from enum import Enum

class Sex(Enum):
    man = 1
    woman = 2
    unknown = 3


  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.

然后在使用的时候就可以直接 Sex.main 直接调用。

Go 的实现

在 Go 语言中,我们如果要实现枚举,则需要使用常量计数器 iota 结合 const 来实现。

iota 是 go 语言的常量计数器,只能在 const 里面使用。

比如:

const(
 SexMan = iota
 SexWoman
 SexUnknown
)

func main()  {

 fmt.Println(SexMan,SexWoman,SexUnknown)
}

// 执行结果
$ go run main.go
0 1 2


  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.

首先我们知道 const 是用来定义常量的,后面接括号就是定义一组常量。

我们给第一个常量赋值为 iota,在这组常量中,之后的常量就会为我们自动赋值递增。

iota有啥特点

?iota 在 const 关键字出现时,在 const 内部的第一行之前就被初始化为 0 了,const 中每增加一行常量声明就将自动加 1 ,哪怕是 _ 这种声明。

const(
 SexMan = iota
 SexWoman
 _
 SexUnknown
)

func main()  {

 fmt.Println(SexMan,SexWoman,SexUnknown)
}

// 执行结果
$ go run main.go
0 1 3


  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.

你会发现,最后一个变量的值变了。

其他情况

还会出现这种情况

const(
 SexMan = iota
 SexWoman = "woman"
 SexUnknown
)

func main()  {

 fmt.Println(SexMan,SexWoman,SexUnknown)
}

// 执行结果
$ go run main.go
0 woman woman


  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.

在出现了 iota 的常量定义中,如果有一个值被特殊赋值后,后面的值都会一样。

解决办法就是在需要恢复计数的地方再次赋值 iota 即可:

const(
 SexMan = iota
 SexWoman = "woman"
 SexUnknown = iota
 SexUnknown1
)

func main()  {

 fmt.Println(SexMan,SexWoman,SexUnknown,SexUnknown1)
}

// 执行结果
$ go run main.go
0 woman 2 3


  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.

技巧升级

我们在定义枚举时,常常会显示的声明其类型,比如这样:

type Sex int

const(
 SexMan Sex = iota
 SexWoman
 SexUnknown
)


  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.

为什么要这样做呢?

这样做有一个好处,我们可以对我们的 Sex 类型进行扩展。

比如这样:

type Sex int

func (this Sex) String() string {
 switch this {
 case 0:
  return "男"
 case 1:
  return "女"
 default:
  return "未知"
 }
}

const(
 SexMan Sex = iota
 SexWoman
 SexUnknown
)

func main()  {

 fmt.Println(SexMan,SexWoman,SexUnknown)
}

// 执行结果
$ go run main.go
男 女 未知


  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.

fmt 在 println 时会去调用这个变量的 String 方法,于是打印就会出现男、女、未知了。

当然你还可以根据你的需要,进行扩展哇。

你学废了么?

责任编辑:武晓燕 来源: GoLang全栈
相关推荐

2017-01-18 15:38:20

语言

2021-04-20 13:59:37

云计算

2024-01-16 07:46:14

FutureTask接口用法

2024-08-30 08:50:00

2022-02-17 09:24:11

TypeScript编程语言javaScrip

2020-06-30 10:45:28

Web开发工具

2024-06-06 08:50:43

2024-01-12 07:38:38

AQS原理JUC

2024-07-05 09:31:37

2021-02-03 14:31:53

人工智能人脸识别

2020-03-08 16:45:58

数据挖掘学习数据量

2024-09-13 08:49:45

2024-02-22 07:37:37

对象JVM内存

2024-05-16 11:13:16

Helm工具release

2009-11-09 12:55:43

WCF事务

2024-12-18 10:24:59

代理技术JDK动态代理

2023-12-27 08:15:47

Java虚拟线程

2020-11-03 09:20:30

MySQLOracle数据库

2013-06-28 14:30:26

棱镜计划棱镜棱镜监控项目

2019-12-05 10:00:03

架构Redis服务器
点赞
收藏

51CTO技术栈公众号