Was ist eine idiomatische Art der Darstellung von Enums in Go?

Question

Ich versuche, ein vereinfachtes Chromosom darzustellen, das aus N Basen besteht, von denen jede nur eine der folgenden sein kann {A, C, T, G} .

Ich möchte die Einschränkungen mit einem enum formalisieren, aber ich frage mich, was die meisten idiomatischen Weg der Emulation eines enum in Go ist.

Answer 1

Ich habe die Aufzählung auf diese Weise erstellt. Angenommen, wir benötigen eine Aufzählung, die das Geschlecht darstellt. Mögliche Werte sind Male, Female, Others

package gender

import (
    "fmt"
    "strings"
)

type Gender struct {
    g string
}

var (
    Unknown = Gender{}
    Male    = Gender{g: "male"}
    Female  = Gender{g: "female"}
    Other   = Gender{g: "other"}
)

var genders = []Gender{
    Unknown,
    Male,
    Female,
    Other,
}

func Parse(code string) (parsed Gender, err error) {
    for _, g := range genders {
        if g.g == strings.ToLower(code) {
            if g == Unknown {
                err = fmt.Errorf("unknown gender")
            }
            parsed = g
            return
        }
    }

    parsed = Unknown
    err = fmt.Errorf("unknown gender", code)
    return
}

func (g Gender) Gender() string {
    return g.g
}

Answer 2

Dies ist ein sicherer Weg, um enum in golang zu implementieren:

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)
}

Das Ergebnis:

Colors = [RED GREEN BLUE]
Genders = [1 2]

Answer 3

Außerdem ist dies eine ziemlich effektive Methode, um verschiedene Rollen an einer Stelle in einem Byte zu speichern, wobei der erste Wert auf 1 gesetzt und um ein Jota verschoben wird.

package main

import "fmt"

const (
    isCaptain = 1 << iota
    isTrooper
    isMedic

    canFlyMars
    canFlyJupiter
    canFlyMoon
)

func main() {
    var roles byte = isCaptain | isMedic | canFlyJupiter
    //Prints a binary representation.
    fmt.Printf("%b\n", roles)
    fmt.Printf("%b\n", isCaptain)
    fmt.Printf("%b\n", isTrooper)
    fmt.Printf("%b\n", isMedic)

    fmt.Printf("Is Captain? %v\n", isCaptain&roles == isCaptain)
    fmt.Printf("Is Trooper? %v", isTrooper&roles == isTrooper)

}

Answer 4

Ich habe einen einfacheren Weg gefunden, der funktioniert.

const (
Stake TX = iota
Withdraw)

type TX int

func (t TX) String() string {
return [...]string{"STAKE", "WITHDRAW"}[t]}

log.Println(Stake.String()) --> STAKE