我试图表示一个简化的染色体，它由N个碱基组成，每个碱基只能是{a, C, T, G}中的一个。
我想用枚举形式化约束，但我想知道在Go中模拟枚举的最惯用的方式是什么。
当前回答
这是在golang中实现enum的安全方法:
package main
import (
"fmt"
)
const (
MALE = _gender(1)
FEMALE = _gender(2)
RED = _color("RED")
GREEN = _color("GREEN")
BLUE = _color("BLUE")
)
type Gender interface {
_isGender()
Value() int
}
type _gender int
func (_gender) _isGender() {}
func (_g _gender) Value() int {
return int(_g)
}
type Color interface {
_isColor()
Value() string
}
type _color string
func (_color) _isColor() {}
func (_c _color) Value() string {
return string(_c)
}
func main() {
genders := []Gender{MALE, FEMALE}
colors := []Color{RED, GREEN, BLUE}
fmt.Println("Colors =", colors)
fmt.Println("Genders =", genders)
}
输出:
Colors = [RED GREEN BLUE]
Genders = [1 2]
其他回答
我找到了一个更简单的方法。
const (
Stake TX = iota
Withdraw)
type TX int
func (t TX) String() string {
return [...]string{"STAKE", "WITHDRAW"}[t]}
log.Println(Stake.String()) --> STAKE
对于这样的用例，使用字符串常量可能很有用，这样就可以将其封送到JSON字符串中。在下例中，[]碱基{A,C,G,T}将被编组为["腺嘌呤"，"胞嘧啶"，"鸟嘌呤"，"胸腺嘧啶"]。
type Base string
const (
A Base = "adenine"
C = "cytosine"
G = "guanine"
T = "thymine"
)
当使用iota时，值被封送成整数。在下面的例子中，[]基数{A,C,G,T}将被封送到[0,1,2,3]。
type Base int
const (
A Base = iota
C
G
T
)
下面是一个比较两种方法的例子:
https://play.golang.org/p/VvkcWvv-Tvj
这是在golang中实现enum的安全方法:
package main
import (
"fmt"
)
const (
MALE = _gender(1)
FEMALE = _gender(2)
RED = _color("RED")
GREEN = _color("GREEN")
BLUE = _color("BLUE")
)
type Gender interface {
_isGender()
Value() int
}
type _gender int
func (_gender) _isGender() {}
func (_g _gender) Value() int {
return int(_g)
}
type Color interface {
_isColor()
Value() string
}
type _color string
func (_color) _isColor() {}
func (_c _color) Value() string {
return string(_c)
}
func main() {
genders := []Gender{MALE, FEMALE}
colors := []Color{RED, GREEN, BLUE}
fmt.Println("Colors =", colors)
fmt.Println("Genders =", genders)
}
输出:
Colors = [RED GREEN BLUE]
Genders = [1 2]
从Go 1.4开始，Go生成工具已经与stringer命令一起引入，使枚举易于调试和打印。
的确，上面使用const和iota的例子是在Go中表示原始枚举的最惯用的方式。但是，如果您正在寻找一种方法来创建功能更全的枚举，类似于您在其他语言(如Java或Python)中看到的类型，该怎么办呢?
在Python中创建一个看起来像字符串enum的对象的一个非常简单的方法是:
package main
import (
"fmt"
)
var Colors = newColorRegistry()
func newColorRegistry() *colorRegistry {
return &colorRegistry{
Red: "red",
Green: "green",
Blue: "blue",
}
}
type colorRegistry struct {
Red string
Green string
Blue string
}
func main() {
fmt.Println(Colors.Red)
}
假设您还需要一些实用程序方法，如Colors.List()和Colors.Parse("red")。你的颜色更复杂，需要一个结构。然后你可以这样做:
package main
import (
"errors"
"fmt"
)
var Colors = newColorRegistry()
type Color struct {
StringRepresentation string
Hex string
}
func (c *Color) String() string {
return c.StringRepresentation
}
func newColorRegistry() *colorRegistry {
red := &Color{"red", "F00"}
green := &Color{"green", "0F0"}
blue := &Color{"blue", "00F"}
return &colorRegistry{
Red: red,
Green: green,
Blue: blue,
colors: []*Color{red, green, blue},
}
}
type colorRegistry struct {
Red *Color
Green *Color
Blue *Color
colors []*Color
}
func (c *colorRegistry) List() []*Color {
return c.colors
}
func (c *colorRegistry) Parse(s string) (*Color, error) {
for _, color := range c.List() {
if color.String() == s {
return color, nil
}
}
return nil, errors.New("couldn't find it")
}
func main() {
fmt.Printf("%s\n", Colors.List())
}
在这一点上，当然它可以工作，但你可能不喜欢你必须重复定义颜色。如果此时您想消除这种情况，您可以在结构上使用标签并进行一些花哨的反射来设置它，但希望这足以覆盖大多数人。
