Go中你用对枚举了么？

枚举的本质是什么，我们天天写代码用枚举，那啥是枚举啊。wiki上是这么说的

  • In computer programming, an enumerated type (also called enumeration, enum, or factor in the R programming language, and a categorical variable in statistics) is a data type consisting of a set of named values called elements, members, enumeral, or enumerators of the type. The enumerator names are usually identifiers that behave as constants in the language. An enumerated type can be seen as a degenerate tagged union of unit type. A variable that has been declared as having an enumerated type can be assigned any of the enumerators as a value. In other words, an enumerated type has values that are different from each other, and that can be compared and assigned, but are not specified by the programmer as having any particular concrete representation in the computer’s memory; compilers and interpreters can represent them arbitrarily.

用人话说就是

枚举是强类型编程语言中的一种类型，由一组名称和值组成。通常用来在编程语言中充当常量的标识符。

没毛病，我们也确实是这样使用的。比如上学的时候，经常写c的小玩具代码，c标准里面提供了enum关键字，写起来比较直白，使用的时候和struct类似,需要enum week这样写，c里面默认枚举值是从0开始，int类型，其实c里面就是把枚举当做int类型来用的。

 
 
 
 
    
  
  
  
  
  1. #include 
    2. 
  
  
  
  
  2.   
    3. 
  
  
  
  
  3. enum week{Mon, Tue, Wed, Thur, Fri, Sat, Sun}; 
    4. 
  
  
  
  
  4.   
    5. 
  
  
  
  
  5. int main() 
    6. 
  
  
  
  
  6. { 
    7. 
  
  
  
  
  7.     enum week day;             // 需要加 enum 关键字
    8. 
  
  
  
  
  8.     day = Wed; 
    9. 
  
  
  
  
  9.     printf("%d",day);          // 输出 2
    10. 
  
  
  
  
  10.     int i; 
    11. 
  
  
  
  
  11.     for (i=Mon; i<=Sun; i++){  // 可以直接把枚举类型赋值给int类型
    12. 
  
  
  
  
  12.       printf("%d ", i);        // 输出 0，1，2，3，4，5，6
    13. 
  
  
  
  
  13.     }
    14. 
  
  
  
  
  14.     return 0; 
    15. 
  
  
  
  
  15. }  
    16.

上面的例子没问题，在初始化的时候，枚举值默认情况下，编译器会从分配0开始的值，例如上面的Mon=0，Tue=1…，但是也会想不按照编译器的默认分配方式，由我自己分配，那怎么写呢，看下面的例子：

 
 
 
 
    
  
  
  
  
  1. #include  
    2. 
  
  
  
  
  2. enum day {sunday = 1, monday, tuesday = 5, 
    3. 
  
  
  
  
  3.           wednesday, thursday = 10, friday, saturday}; 
    4. 
  
  
  
  
  4.   
    5. 
  
  
  
  
  5. int main() 
    6. 
  
  
  
  
  6. { 
    7. 
  
  
  
  
  7.     printf("%d %d %d %d %d %d %d", sunday, monday, tuesday, 
    8. 
  
  
  
  
  8.             wednesday, thursday, friday, saturday); // 输出1 2 5 6 10 11 12
    9. 
  
  
  
  
  9.     return 0; 
    10. 
  
  
  
  
  10. } 
    11.

也就是说，枚举里面可以按任何顺序将值分配给某个名称。所有未分配的名称都会把值作为前一个名称的值加一。

其实，定义几个常量的事，是不是用宏这个东西更好呢，比如这么写

 
 
 
 
    
  
  
  
  
  1. #define sunday  0 
    2. 
  
  
  
  
  2. #define monday  1 
    3. 
  
  
  
  
  3. #define tuesday 2
    4.

但是老师说了，尽量别用宏，不是说宏不好，宏也好，编译器替换，没有运行期啥事，多快啊，但是有几个问题：

1)宏没有作用域一说 2)枚举是类型安全的

扯的有点远了，现在回来看看Go里面的枚举怎么写。当然也很简单了，官方教导我们这么写：

 
 
 
 
    
  
  
  
  
  1. type ByteSize float64
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. const (
    4. 
  
  
  
  
  4.     _           = iota
    5. 
  
  
  
  
  5.     KB ByteSize = 1 << (10 * iota)
    6. 
  
  
  
  
  6.     MB
    7. 
  
  
  
  
  7.     GB
    8. 
  
  
  
  
  8. )
    9.

Go里面更简洁了，直接把enum关键字去掉了，其实从Go的角度看，枚举不就是常量么，搞这么多语法糖干嘛，Go里面提供了一个关键字iota可以实现常量的递增，同时也支持手动赋值，iota和手动赋值结合起来，就可以实现类似c里面的效果

 
 
 
 
    
  
  
  
  
  1. const (
    2. 
  
  
  
  
  2.     A0 = iota
    3. 
  
  
  
  
  3.     A1 = iota
    4. 
  
  
  
  
  4.     A2 = iota
    5. 
  
  
  
  
  5. )
    6. 
  
  
  
  
  6. fmt.Println(A0, A1, A2) // "0 1 2"
    7.

可以 简写成这样

 
 
 
 
    
  
  
  
  
  1. const (
    2. 
  
  
  
  
  2.     A0 = iota
    3. 
  
  
  
  
  3.     A1
    4. 
  
  
  
  
  4.     A2
    5. 
  
  
  
  
  5. )
    6.

也可以从1开始

 
 
 
 
    
  
  
  
  
  1. const (
    2. 
  
  
  
  
  2.     A1 = iota + 1
    3. 
  
  
  
  
  3.     A2
    4. 
  
  
  
  
  4.     A3
    5. 
  
  
  
  
  5. )
    6. 
  
  
  
  
  6. fmt.Println(A1, A2, A3) // "1 2 3"
    7.

或者跳过某个值

 
 
 
 
    
  
  
  
  
  1. const (
    2. 
  
  
  
  
  2.     C1 = iota + 1
    3. 
  
  
  
  
  3.     _
    4. 
  
  
  
  
  4.     C3
    5. 
  
  
  
  
  5.     C4
    6. 
  
  
  
  
  6. )
    7. 
  
  
  
  
  7. fmt.Println(C1, C3, C4) // "1 3 4"
    8.

看到这里你或许有个疑问，这里的枚举其实就是常量么，那怎么写是字符串类型的枚举呢，你可能会说，当然是用字符串常量了。但是那只是字符串常量了，没有枚举的性质。我可能想要的是一种字符串到值的枚举类型。思考再三，看我这种写法是否可以：

  • 步骤一：创建一个新的int类型
  • 步骤二：使用iota表示值
  • 步骤三：给这个新的类型一个String的方法
 
 
 
 
    
  
  
  
  
  1. type Direction int
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. const (
    4. 
  
  
  
  
  4.     North Direction = iota
    5. 
  
  
  
  
  5.     East
    6. 
  
  
  
  
  6.     South
    7. 
  
  
  
  
  7.     West
    8. 
  
  
  
  
  8. )
    9. 
  
  
  
  
  9. 
  
  
  
  
  10. func (d Direction) String() string {
    11. 
  
  
  
  
  11.     return [...]string{"North", "East", "South", "West"}[d]
    12. 
  
  
  
  
  12. }
    13.

使用的时候

 
 
 
 
    
  
  
  
  
  1. var d Direction = North
    2. 
  
  
  
  
  2. fmt.Print(d)
    3. 
  
  
  
  
  3. switch d {
    4. 
  
  
  
  
  4. case North:
    5. 
  
  
  
  
  5.     fmt.Println(" goes up.")
    6. 
  
  
  
  
  6. case South:
    7. 
  
  
  
  
  7.     fmt.Println(" goes down.")
    8. 
  
  
  
  
  8. default:
    9. 
  
  
  
  
  9.     fmt.Println(" stays put.")
    10. 
  
  
  
  
  10. }
    11.

当然还有一种方法，比较stupid

 
 
 
 
    
  
  
  
  
  1. type weekday string
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. func (w weekday) isWeekday() weekday {
    4. 
  
  
  
  
  4.     return w
    5. 
  
  
  
  
  5. }
    6. 
  
  
  
  
  6. 
  
  
  
  
  7. type Weekday interface {
    8. 
  
  
  
  
  8.     isWeekday() weekday
    9. 
  
  
  
  
  9. }
    10. 
  
  
  
  
  10. 
  
  
  
  
  11. const (
    12. 
  
  
  
  
  12.     Monday   = weekday("Monday")
    13. 
  
  
  
  
  13.     Tuesday  = weekday("Tuesday")
    14. 
  
  
  
  
  14.     Wendsday = weekday("Wendsday")
    15. 
  
  
  
  
  15.     Thursday = weekday("Thursday")
    16. 
  
  
  
  
  16.     Friday   = weekday("Friday")
    17. 
  
  
  
  
  17.     Saturday = weekday("Saturday")
    18. 
  
  
  
  
  18.     Sunday   = weekday("Sunday")
    19. 
  
  
  
  
  19. )
    20. 
  
  
  
  
  20. // 使用
    21. 
  
  
  
  
  21. func main() {
    22. 
  
  
  
  
  22.     var d1 = weekday.Monday
    23. 
  
  
  
  
  23.     var d2 = weekday.Tuesday
    24. 
  
  
  
  
  24. 
  
  
  
  
  25.     fmt.Println(d1, d2, d1 == d2, d1 == weekday.Monday)
    26. 
  
  
  
  
  26. }
    27.

如果使用struct表示枚举，那其实还可以使用反射的方式，比如下面这样写：

 
 
 
 
    
  
  
  
  
  1. import (
    2. 
  
  
  
  
  2.    "reflect"
    3. 
  
  
  
  
  3. )
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. type weekday struct {
    6. 
  
  
  
  
  6.    Monday, Tuesday, Wendsday, Thursday, Friday, Saturday, Sunday int
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. 
  
  
  
  
  9. func (c weekday) Get(id string) int {
    10. 
  
  
  
  
  10.    vo := reflect.ValueOf(c)
    11. 
  
  
  
  
  11.    typeVo := vo.Type()
    12. 
  
  
  
  
  12. 
  
  
  
  
  13.    for i := 0; i < vo.NumField(); i++ {
    14. 
  
  
  
  
  14.       if typeVo.Field(i).Name == id {
    15. 
  
  
  
  
  15.          return vo.Field(i).Interface().(int)
    16. 
  
  
  
  
  16.       }
    17. 
  
  
  
  
  17.    }
    18. 
  
  
  
  
  18.    return 0
    19. 
  
  
  
  
  19. }
    20. 
  
  
  
  
  20. 
  
  
  
  
  21. var weekdayEnum = weekday {
    22. 
  
  
  
  
  22.    Monday:   1,
    23. 
  
  
  
  
  23.    Tuesday:  2,
    24. 
  
  
  
  
  24.    Wendsday: 3,
    25. 
  
  
  
  
  25.    Thursday: 4,
    26. 
  
  
  
  
  26.    Friday:   5，
    27. 
  
  
  
  
  27.    Saturday: 6,
    28. 
  
  
  
  
  28.    Sunday:   7
    29. 
  
  
  
  
  29. }
    30.

本文转载自微信公众号「码小菜」，可以通过以下二维码关注。转载本文请联系码小菜公众号。

分享名称：Go中你用对枚举了么？
标题网址：http://www.shufengxianlan.com/qtweb/news35/418335.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

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

猜你还喜欢下面的内容

网站建设知识

同城分类信息

成都网站设计制作公司　　 　成都网站建设　　 　成都电商解决方案　　 　成都圣月窗帘　　 　微信开发　　 　成都艺考培训　　 　高端定制网站设计　　 　联通机房服务器托管　　 　成都网站建设　　 　成都户外广告牌设计　　 　绵阳服务器托管　　 　网站推广公司　　 　重庆网站制作　　 　名片印刷　　 　美美搬家　　 　电子商务商城网站　　 　巴彦网站建设　　 　成都网站建设　　 　服务器托管　　 　成都手机网站建设