Go中代表枚举的惯用方式是什么？ [英] What is an idiomatic way of representing enums in Go?

问题描述

我正在试图表示一个简化的染色体，它由N个碱基组成，每个碱基只能是 {A，C，T，G} 之一。

我想使用枚举来限制约束，但我想知道在Go中最常用的模拟枚举的方法是什么。

解决方案

从语言规范中引用： Iota

在常量声明中，预先声明的标识符iota表示连续的无类型整数常量。每当保留字常数出现在源中并在每个ConstSpec后递增，它将复位为0。它可以用于构造一组相关的常量：

  const（// iota is重置为0 
 c0 = iota // c0 == 0 
 c1 = iota // c1 == 1 
 c2 = iota // c2 == 2 
）
 
 const（
a = 1< iota // a == 1（iota已被重置）
b = 1< iota // b == 2 
c = 1< iota // c == 4 
）
 
 const（
u = iota * 42 // u == 0（无类型整数常量）
v float64 = iota * 42 // v == 42.0（float64 constant）
w = iota * 42 // w == 84（无类型整数常量）
）
 
 const x = iota // x == 0（iota已被重置）
 const y = iota // y == 0（iota已重置）
  

在一个表达式列表中，每个iota的值是相同的，因为它只在每个ConstSpec之后递增：

  const（
 bit0，mask0 = 1 < iota，1< i  -  1 // bit0 == 1，mask0 == 0 
 bit1，mask1 // bit1 == 2，mask1 == 1 
 _，_ // skips iota = = 2 
 bit3，mask3 // bit3 == 8，mask3 == 7 
）
  

最后一个例子利用最后一个非空表达式列表的隐式重复。

---

所以你的代码可能就像

  const（
 A = iota 
 C 
 T 
 G 
）
  

或

  type Base int 
 
 const（
 A Base = iota 
 C 
 T 
 G 
）
  

一个单独的类型从int。

I'm trying to represent a simplified chromosome, which consists of N bases, each of which can only be one of {A, C, T, G}.

I'd like to formalize the constraints with an enum, but I'm wondering what the most idiomatic way of emulating an enum is in Go.

解决方案

Quoting from the language specs:Iota

Within a constant declaration, the predeclared identifier iota represents successive untyped integer constants. It is reset to 0 whenever the reserved word const appears in the source and increments after each ConstSpec. It can be used to construct a set of related constants:

const (  // iota is reset to 0
        c0 = iota  // c0 == 0
        c1 = iota  // c1 == 1
        c2 = iota  // c2 == 2
)

const (
        a = 1 << iota  // a == 1 (iota has been reset)
        b = 1 << iota  // b == 2
        c = 1 << iota  // c == 4
)

const (
        u         = iota * 42  // u == 0     (untyped integer constant)
        v float64 = iota * 42  // v == 42.0  (float64 constant)
        w         = iota * 42  // w == 84    (untyped integer constant)
)

const x = iota  // x == 0 (iota has been reset)
const y = iota  // y == 0 (iota has been reset)

Within an ExpressionList, the value of each iota is the same because it is only incremented after each ConstSpec:

const (
        bit0, mask0 = 1 << iota, 1<<iota - 1  // bit0 == 1, mask0 == 0
        bit1, mask1                           // bit1 == 2, mask1 == 1
        _, _                                  // skips iota == 2
        bit3, mask3                           // bit3 == 8, mask3 == 7
)

This last example exploits the implicit repetition of the last non-empty expression list.

---

So your code might be like

const (
        A = iota
        C
        T
        G
)

or

type Base int

const (
        A Base = iota
        C
        T
        G
)

if you want bases to be a separate type from int.

这篇关于Go中代表枚举的惯用方式是什么？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！