Go中更安全的枚举

iota

Go让你用iota来使用枚举。

const(
    Guest =iota
    Member
    Moderator
    Admin
)

虽然Go是明确的，但iota似乎相对模糊。如果你以任何其他方式对const组进行排序，你会引入副作用。在上面的例子中，你仅仅对第一个参数Guest赋值了。你可以显式地给每个值分配一个数字来避免这个问题，但这使iota变得过时。
iota对于用位运算定义的参数也很有效。

const(
    Guest =1<<iota// 1
    Member            // 2
    Moderator         // 4
    Admin             // 8)// ...

user.Roles = Member | Moderator // 6

位掩码是有效的，有时也很有帮助。然而，在大多数Web应用程序中，它的使用情况与枚举不同。通常情况下，你可以将所有的角色存储在一个列表中。它也会更容易阅读。

iota的主要问题是它在整数上工作，没有防止传递无效的值。

funcCreateUser(role int)error{
    fmt.Println("Creating user with role", role)returnnil}funcmain(){
    err :=CreateUser(-1)if err !=nil{
        fmt.Println(err)}
    
    err =CreateUser(42)if err !=nil{
        fmt.Println(err)}}

CreateUser会很乐意接受-1或42，即使没有相应的角色。

当然，我们可以在函数中验证这一点。但我们使用的是一种具有强类型的语言，所以让我们利用它。在我们应用程序的上下文中，用户角色远不止是一个模糊的数字。

反模式:整数枚举

不要使用基于iota的整数来表示不是连续的数字或标志的枚举。

我们可以引入一个类型来改进解决方案。

type Role uintconst(
    Guest Role =iota
    Member
    Moderator
    Admin
)

它看起来更好，但仍有可能传递任何任意的整数来代替Role。Go编译器在这里并没有帮助我们。

funcCreateUser(role Role)error{
    fmt.Println("Creating user with role", role)returnnil}func main (){
    err :=CreateUser(0)if err !=nil{
        fmt.Println(err)}
    
    err =CreateUser(role.Role(42))if err !=nil{
        fmt.Println(err)}}

这个类型是对裸整数的改进，但它仍然是一种幻觉。它并没有给我们提供任何保证，说明这个角色是有效的。

哨兵值

因为iota从0开始，Guest也是角色的零值。这使得我们很难检测到角色是空的还是有人传递了一个Guest值。
你可以通过从1开始计算来避免这种情况。甚至更好的是，保留一个明确的哨兵值，你可以进行比较，不能误认为是一个实际的角色。

const(
    Unknown Role =iota
    Guest
    Member
    Moderator
    Admin
)

funcCreateUser(r role.Role)error{if r == role.Unknown {return errors.New("no role provided")}
    
    fmt.Println("Creating user with role", r)returnnil}

策略：明确的哨兵 为枚举的零值保留一个显式变量。

更准确的描述

枚举似乎是关于连续的整数，但它很少是有效的表示。在网络应用中，我们使用枚举来分组某种类型的可能变体。它们并不能很好地映射到数字上。
当你在API响应、数据库表或日志中看到一个3时，很难理解其背景。你必须检查源码或过时的文档才能知道它是怎么回事。
在大多数情况下，字符串比整数更有意义。无论你在哪里看到它，一个有明确意义的表达都是显而易见的。既然iota无论如何也帮不了我们，我们还可以使用人类可读的字符串。

type Role stringconst(
    Unknown   Role ="unknown"
    Guest     Role ="guest"
    Member    Role ="member"
    Moderator Role ="moderator"
    Admin     Role ="admin")

策略:使用字符串值而不是整数。 避免使用空白，以方便解析和记录。使用camelCase、snake_case或kebab-case。

这样的表达对错误代码特别有用。{“error”:“user-not-found”}与{“error”:4102}相比是显而易见的.
然而，该类型仍然可以容纳任何任意的字符串。

err =CreateUser("super-admin")if err !=nil{
    fmt.Println(err)}

基于结构的枚举

最后的迭代使用了结构体。它可以让我们在设计上保证代码的安全性。我们不需要检查传递的值是否正确。

type Role struct{
    slug string}func(r Role)String()string{return r.slug
}var(
    Unknown   = Role{"unknown"}
    Guest     = Role{"guest"}
    Member    = Role{"member"}
    Moderator = Role{"moderator"}
    Admin     = Role{"admin"})

因为slug字段是私有的，所以不可能从包的外部引用它。你能构建的唯一无效的角色是空的：Role{}。

我们可以添加一个构造函数来创建一个基于slug的有效角色:

funcFromString(s string)(Role,error){switch s {case Guest.slug:return Guest,nilcase Member.slug:return Member,nilcase Moderator.slug:return Moderator,nilcase Admin.slug:return Admin,nil}return Unknown, errors.New("unknown role: "+ s)}

策略:基于结构的枚举 将枚举封装在结构中以获得额外的编译时安全性。

这种方法在你处理业务逻辑时是完美的。保持结构在内存中始终处于有效状态，使你的代码更容易操作和理解。检查枚举类型是否为空就足够了，而且你可以确定它是一个正确的值。
这种方法有一个潜在的问题。如果我们用的是全局性的常亮，这样的做法需要不断的赋值，如下：

roles.Guest = role.Admin

这样的话，这个值说不准在哪里变化了都不知道。

校验方法

竟然上面的方法都无法满足我们的需求，那么我们就加上一个校验方法，避免运行时传入了非法的值即可：

type Role stringconst(
    Unknown   Role ="unknown"
    Guest     Role ="guest"
    Member    Role ="member"
    Moderator Role ="moderator"
    Admin     Role ="admin")var roleSet =[]Role{Unknown, Guest, Member, Moderator, Admin}func(role Role)Valid()bool{for_, r :=range roleSet {if role == r {returntrue}}returnfalse}

这样的做法就可以满足我们对枚举更安全的需求了。