为什么我们需要在Go中使用Iota

本文转载自微信公众号「吴亲强的深夜食堂」，作者吴亲库里。转载本文请联系吴亲强的深夜食堂公众号。  

文登ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联公司的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：18980820575（备注：SSL证书合作）期待与您的合作！

介绍

Go 语言实际上没有直接支持枚举的关键字。一般我们都是通过 const + iota 实现枚举的能力。

有人要问了，为什么一定要使用枚举呢?stackoverflow[1] 上有一个高赞的回答，如下:

You should always use enums when a variable (especially a method parameter) can only take one out of a small set of possible values. Examples would be things like type constants (contract status: "permanent", "temp", "apprentice"), or flags ("execute now", "defer execution").

If you use enums instead of integers (or String codes), you increase compile-time checking and avoid errors from passing in invalid constants, and you document which values are legal to use.

简单翻译一下， 两点很重要。

  • 当一个变量(尤其是方法参数) 只能从一小部分可能的值中取出一个时，理应使用枚举。例如类型常量(合同状态：永久、临时工、学徒)， 或者在做任务程序时，是立即执行还是延迟执行的标记。
  • 如果使用枚举而不是整形，则会增加编译时的检查，避免错误无效值的传入，记录哪些值是合法使用的。

如何实现枚举

iota 是 Go 中预声明的一个特殊常量。它会被预声明为0，但是它的值在编译阶段并非是固定的，当预声明的 iota 出现在一个常量声明中，它的值在第n个常量描述中的值为n(从0开始)。

比如，大家都或多或少了解电商系统。其中的订单模块一定会涉及到订单状态的流转。那么这时候，我们一般可以这样定义:

  
 
 
    
   
  
  
  1. package main 
    2. 
   
  
  
  2.  
    3. 
   
  
  
  3. import "fmt" 
    4. 
   
  
  
  4.  
    5. 
   
  
  
  5. type OrderStatus int 
    6. 
   
  
  
  6.  
    7. 
   
  
  
  7. const ( 
    8. 
   
  
  
  8.   Cancelled OrderStatus = iota //订单已取消 0 
    9. 
   
  
  
  9.   NoPay OrderStatus = iota //未支付 1 
    10. 
   
  
  
  10.   PendIng OrderStatus = iota // 未发货 2 
    11. 
   
  
  
  11.   Delivered OrderStatus = iota // 已发货 3 
    12. 
   
  
  
  12.   Received OrderStatus = iota // 已收货 4 
    13. 
   
  
  
  13. ) 
    14. 
   
  
  
  14.  
    15. 
   
  
  
  15. func main() { 
    16. 
   
  
  
  16.   fmt.Println(Cancelled, NoPay) // 打印:0,1 
    17. 
   
  
  
  17. } 
    18.

当然，这样看着好麻烦。其实，其他常量可以重复上一行 iota 表达式，我们可以改成这样。

  
 
 
    
   
  
  
  1. package main 
    2. 
   
  
  
  2.  
    3. 
   
  
  
  3. import "fmt" 
    4. 
   
  
  
  4.  
    5. 
   
  
  
  5. type OrderStatus int 
    6. 
   
  
  
  6.  
    7. 
   
  
  
  7. const ( 
    8. 
   
  
  
  8.   Cancelled OrderStatus = iota //订单已取消 0 
    9. 
   
  
  
  9.   NoPay //未支付 1 
    10. 
   
  
  
  10.   PendIng // 未发货 2 
    11. 
   
  
  
  11.   Delivered // 已发货 3 
    12. 
   
  
  
  12.   Received // 已收货 4 
    13. 
   
  
  
  13. ) 
    14. 
   
  
  
  14.  
    15. 
   
  
  
  15. func main() { 
    16. 
   
  
  
  16.   fmt.Println(Cancelled, NoPay) // 打印:0,1 
    17. 
   
  
  
  17. } 
    18.

有人会用 0 的值来表示状态吗?一般都不会，我们想以1开头，那么可以这样。

  
 
 
    
   
  
  
  1. package main 
    2. 
   
  
  
  2.  
    3. 
   
  
  
  3. import "fmt" 
    4. 
   
  
  
  4.  
    5. 
   
  
  
  5. type OrderStatus int 
    6. 
   
  
  
  6.  
    7. 
   
  
  
  7. const ( 
    8. 
   
  
  
  8.   Cancelled OrderStatus = iota+1 //订单已取消 1 
    9. 
   
  
  
  9.   NoPay //未支付 2 
    10. 
   
  
  
  10.   PendIng // 未发货 3 
    11. 
   
  
  
  11.   Delivered // 已发货 4 
    12. 
   
  
  
  12.   Received // 已收货 5 
    13. 
   
  
  
  13. ) 
    14. 
   
  
  
  14.  
    15. 
   
  
  
  15. func main() { 
    16. 
   
  
  
  16.   fmt.Println(Cancelled, NoPay) // 打印:1,2 
    17. 
   
  
  
  17. } 
    18.

我们还想在 Delivered 后跳过一个数字，才是 Received 的值,也就是 Received=6，那么可以借助 _ 符号。

  
 
 
    
   
  
  
  1. package main 
    2. 
   
  
  
  2.  
    3. 
   
  
  
  3. import "fmt" 
    4. 
   
  
  
  4.  
    5. 
   
  
  
  5. type OrderStatus int 
    6. 
   
  
  
  6.  
    7. 
   
  
  
  7. const ( 
    8. 
   
  
  
  8.   Cancelled OrderStatus = iota+1 //订单已取消 1 
    9. 
   
  
  
  9.   NoPay //未支付 2 
    10. 
   
  
  
  10.   PendIng // 未发货 3 
    11. 
   
  
  
  11.   Delivered // 已发货 4 
    12. 
   
  
  
  12.   _ 
    13. 
   
  
  
  13.   Received // 已收货 6 
    14. 
   
  
  
  14. ) 
    15. 
   
  
  
  15.  
    16. 
   
  
  
  16. func main() { 
    17. 
   
  
  
  17.   fmt.Println(Received) // 打印:6 
    18. 
   
  
  
  18. } 
    19.

顺着来可以，倒着当然也行。

  
 
 
    
   
  
  
  1. package main 
    2. 
   
  
  
  2.  
    3. 
   
  
  
  3. import "fmt" 
    4. 
   
  
  
  4.  
    5. 
   
  
  
  5. type OrderStatus int 
    6. 
   
  
  
  6.  
    7. 
   
  
  
  7. const ( 
    8. 
   
  
  
  8.   Max = 5 
    9. 
   
  
  
  9. ) 
    10. 
   
  
  
  10.  
    11. 
   
  
  
  11. const ( 
    12. 
   
  
  
  12.   Received OrderStatus = Max - iota // 已收货 5 
    13. 
   
  
  
  13.   Delivered // 已发货 4 
    14. 
   
  
  
  14.   PendIng // 未发货 3 
    15. 
   
  
  
  15. NoPay //未支付 2 
    16. 
   
  
  
  16.   Cancelled //订单已取消 1 
    17. 
   
  
  
  17. ) 
    18. 
   
  
  
  18.  
    19. 
   
  
  
  19. func main() { 
    20. 
   
  
  
  20.   fmt.Println(Received,Delivered) // 打印:5,4 
    21. 
   
  
  
  21. } 
    22.

还可以使用位运算，比如在 go 源码中的包 sync 中的锁上面有这么一段定义代码。

  
 
 
    
   
  
  
  1. const ( 
    2. 
   
  
  
  2.     mutexLocked = 1 << iota  //1<<0 
    3. 
   
  
  
  3.     mutexWoken //1<<1 
    4. 
   
  
  
  4.     mutexStarving //1<<2 
    5. 
   
  
  
  5.     mutexWaiterShift = iota  //3 
    6. 
   
  
  
  6.  
    7. 
   
  
  
  7. ) 
    8. 
   
  
  
  8.  
    9. 
   
  
  
  9. func main() { 
    10. 
   
  
  
  10.     fmt.Println("mutexLocked的值",mutexLocked) //打印：1 
    11. 
   
  
  
  11.     fmt.Println("mutexWoken的值",mutexWoken) //打印：2 
    12. 
   
  
  
  12.     fmt.Println("mutexStarving的值",mutexStarving) //打印：4 
    13. 
   
  
  
  13.     fmt.Println("mutexWaiterShift的值",mutexWaiterShift) // 打印：3 
    14. 
   
  
  
  14. } 
    15.

也许有人平常是直接定义常量值或者用字符串来表示的。

比如，上面这些我完全可以用 string 来表示，我还真见过用字符串来表示订单状态的。

  
 
 
    
   
  
  
  1. package main 
    2. 
   
  
  
  2.  
    3. 
   
  
  
  3. import "fmt" 
    4. 
   
  
  
  4.  
    5. 
   
  
  
  5. const ( 
    6. 
   
  
  
  6.   Cancelled = "cancelled" 
    7. 
   
  
  
  7.   NoPay = "noPay" 
    8. 
   
  
  
  8.   PendIng = "pendIng" 
    9. 
   
  
  
  9.   Delivered = "delivered" 
    10. 
   
  
  
  10.   Received = "received" 
    11. 
   
  
  
  11. ) 
    12. 
   
  
  
  12.  
    13. 
   
  
  
  13. var OrderStatusMsg = map[string]string{ 
    14. 
   
  
  
  14.   Cancelled: "订单已取消", 
    15. 
   
  
  
  15.   NoPay: "未付款", 
    16. 
   
  
  
  16.   PendIng: "未发货", 
    17. 
   
  
  
  17.   Delivered: "已发货", 
    18. 
   
  
  
  18.   Received: "已收货", 
    19. 
   
  
  
  19. } 
    20. 
   
  
  
  20.  
    21. 
   
  
  
  21. func main() { 
    22. 
   
  
  
  22.   fmt.Println(OrderStatusMsg[Cancelled]) 
    23. 
   
  
  
  23. } 
    24.

或者直接定义整形常量值。

  
 
 
    
   
  
  
  1. package main 
    2. 
   
  
  
  2.  
    3. 
   
  
  
  3. import "fmt" 
    4. 
   
  
  
  4.  
    5. 
   
  
  
  5. const ( 
    6. 
   
  
  
  6.   Cancelled = 1 
    7. 
   
  
  
  7.   NoPay = 2 
    8. 
   
  
  
  8.   PendIng = 3 
    9. 
   
  
  
  9.   Delivered = 4 
    10. 
   
  
  
  10.   Received = 5 
    11. 
   
  
  
  11. ) 
    12. 
   
  
  
  12.  
    13. 
   
  
  
  13. var OrderStatusMsg = map[int]string{ 
    14. 
   
  
  
  14.   Cancelled: "订单已取消", 
    15. 
   
  
  
  15.   NoPay: "未付款", 
    16. 
   
  
  
  16.   PendIng: "未发货", 
    17. 
   
  
  
  17.   Delivered: "已发货", 
    18. 
   
  
  
  18.   Received: "已收货", 
    19. 
   
  
  
  19. } 
    20. 
   
  
  
  20.  
    21. 
   
  
  
  21. func main() { 
    22. 
   
  
  
  22.   fmt.Println(OrderStatusMsg[Cancelled]) 
    23. 
   
  
  
  23. } 
    24.

其实上述两种都可以，但是相比之下使用 iota 更有优势。

  • 能保证一组常量的唯一性，人工定义的不能保证。
  • 可以为一组动作分享同一种行为。
  • 避免无效值。
  • 提高代码阅读性以及维护。

延伸

按照上面我们所演示的，最后我们可以这样操作。

  
 
 
    
   
  
  
  1. package main 
    2. 
   
  
  
  2.  
    3. 
   
  
  
  3. import ( 
    4. 
   
  
  
  4.   "fmt" 
    5. 
   
  
  
  5. ) 
    6. 
   
  
  
  6.  
    7. 
   
  
  
  7. type OrderStatus int 
    8. 
   
  
  
  8.  
    9. 
   
  
  
  9. const ( 
    10. 
   
  
  
  10.   Cancelled OrderStatus = iota + 1 //订单已取消 1 
    11. 
   
  
  
  11.   NoPay //未支付 2 
    12. 
   
  
  
  12.   PendIng // 未发货 3 
    13. 
   
  
  
  13.   Delivered // 已发货 4 
    14. 
   
  
  
  14.   Received // 已收货 5 
    15. 
   
  
  
  15. ) 
    16. 
   
  
  
  16.  
    17. 
   
  
  
  17. //公共行为 赋予类型 String() 函数，方便打印值含义 
    18. 
   
  
  
  18. func (order OrderStatus) String() string { 
    19. 
   
  
  
  19.   return [...]string{"cancelled", "noPay", "pendIng", "delivered", "received"}[order-1] 
    20. 
   
  
  
  20. } 
    21. 
   
  
  
  21.  
    22. 
   
  
  
  22. //创建公共行为 赋予类型 int 函数 EnumIndex() 
    23. 
   
  
  
  23. func (order OrderStatus) EnumIndex() int { 
    24. 
   
  
  
  24.   return int(order) 
    25. 
   
  
  
  25. } 
    26. 
   
  
  
  26.  
    27. 
   
  
  
  27. func main() { 
    28. 
   
  
  
  28.   var order OrderStatus = Received 
    29. 
   
  
  
  29.   fmt.Println(order.String()) // 打印:received 
    30. 
   
  
  
  30.   fmt.Println(order.EnumIndex()) // 打印:5 
    31. 
   
  
  
  31. } 
    32.

总结

这篇文章主要介绍了 Golang 中对 iota 的使用介绍，以及我们为什么要使用它。

不知道大家平常对于此类场景用的什么招数，欢迎下方留言交流。

附录

[1]

https://stackoverflow.com/questions/4709175/what-are-enums-and-why-are-they-useful

https://levelup.gitconnected.com/implementing-enums-in-golang-9537c433d6e2

https://medium.com/qvault/how-and-why-to-write-enums-in-go-9c1a25649df0

本文标题：为什么我们需要在Go中使用Iota
网站地址：http://www.mswzjz.cn/qtweb/news32/69582.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 贝锐智能

贝锐智能技术为您推荐以下文章

静态网站知识

分类信息网站

成都门窗定制　　 　成都广告制作　　 　西云服务器托管　　 　成都西信机房　　 　联通机房服务器托管　　 　成都免费建网站　　 　阿坝网站建设　　 　成都app软件开发　　 　乐山企业网站设计　　 　四川正泰动物　　 　四川主机托管　　 　不锈钢防护栏　　 　顺泽窗帘　　 　品牌网站建设　　 　成都模板网站　　 　眉山网站建设　　 　资阳网站建设　　 　瑞杰管理　　 　四川主机托管　　 　品牌网站建设公司