Gehen Sie zu den Problemen und Lösungen von Enum mit xybor-x/enum

Was ist Enumeration?

Eine Enumeration, kurz für Enumeration, ist ein spezieller Datentyp, der eine Reihe benannter Werte darstellt. Es wird verwendet, um eine Sammlung konstanter Werte zu definieren, die konzeptionell miteinander in Zusammenhang stehen, wodurch die Lesbarkeit des Codes verbessert und Fehler reduziert werden, die durch die Verwendung beliebiger Literalwerte verursacht werden.

// Enum in Java
enum TrafficLight {
    RED, YELLOW, GREEN
}

# Enum in Python
from enum import Enum

class TrafficLight(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

Aufzählung in Go

Go unterstützt Enum nicht nativ. Es gibt jedoch eine beliebte Möglichkeit, eine Aufzählung in Go zu definieren, indem der Iota-Ansatz verwendet wird.

package main

type TrafficLight int

const (
    RED TrafficLight = iota // 0
    GREEN                   // 1
    BLUE                    // 2
)

func main() {
    fmt.Println(RED) // Output: 0
}

Es gibt jedoch einige Probleme, wenn man auf diese Weise mit Enum umgeht:

• Mangel an integrierten Methoden: Keine direkte Unterstützung für Funktionen wie das Auflisten aller Enum-Werte oder das Konvertieren zwischen Strings und Enums.
• Eingeschränkte Typsicherheit: Aufzählungen werden normalerweise durch Basistypen (z. B. int oder string) dargestellt, was das Risiko unbeabsichtigter Zuweisungen erhöht.
• Serialisierungs- und Deserialisierungskomplexität: Die Zuordnung von Aufzählungen zu und von Formaten wie JSON erfordert zusätzliche Handhabung.

Die xybor-x/enum-Bibliothek

Die xybor-x/enum-Bibliothek bietet elegante, benutzerfreundliche und leistungsstarke Lösungen für Go-Enum ohne Codegenerierung.

Es gibt einige Arten von Enumerationen, mit denen Sie xybor-x/enum arbeiten können. Bitte wählen Sie die am besten geeignete aus.

Grundlegende Aufzählung

Vorteile?

• Einfach.
• Unterstützt konstante Werte.

Nachteile ?

• Keine integrierten Methoden.
• Keine Typensicherheit.
• Es fehlt die Unterstützung für Serialisierung und Deserialisierung. Wie die traditionelle Aufzählung verfügt auch die Basis-Aufzählung über keine integrierten Methoden. Sie können jedoch die Hilfsfunktionen von xybor-x/enum verwenden, um diese Art von Aufzählung zu verarbeiten.

package main

type Role int

const (
    RoleUser Role = iota
    RoleAdmin
)

func init() {
    enum.Map(RoleUser, "user")
    enum.Map(RoleAdmin, "admin")

    // Optional: ensure no new enum values can be added to Role.
    enum.Finalize[Role]()
}

func main() {
    // Print the corresponding string.
    fmt.Println(enum.ToString(RoleUser)) // Output: user

    // Print out all valid enums.
    fmt.Println(enum.All[Role]())       // Output: [0 1]

    // Parse an enum from int.
    r1, ok := enum.FromInt[Role](1)
    fmt.Println(ok)                // Output: true
    fmt.Println(enum.ToString(r1)) // Output: admin

    // Parse an enum from string.
    r2, ok := enum.FromString[Role]("admin")
    fmt.Println(ok) // Output: true
    fmt.Println(r2) // Output: 1

    // Serialize json.
    data, err := enum.MarshalJSON(RoleUser)
    fmt.Println(err)          // Output: nil
    fmt.Println(string(data)) // Output: "user"
}

WrapEnum

Vorteile?

• Unterstützt konstante Werte.
• Bietet viele nützliche integrierte Methoden.
• Vollständige Serialisierungs- und Deserialisierungsunterstützung sofort einsatzbereit.

Nachteile ?

• Bietet nur grundlegende Typsicherheit.

package main

// Only need to change the two following lines fromthe Basic enum.
type role any
type Role = enum.WrapEnum[role]

const (
    RoleUser Role = iota
    RoleAdmin
)

func init() {
    enum.Map(RoleUser, "user")
    enum.Map(RoleAdmin, "admin")

    // Optional: ensure no new enum values can be added to Role.
    enum.Finalize[Role]()
}

func main() {
    // Print the corresponding string. No need to use enum.ToString.
    fmt.Println(RoleUser) // Output: user

    // Print out all valid enums.
    fmt.Println(enum.All[Role]())       // Output: [user admin]

    // Parse an enum from int.
    r1, ok := enum.FromInt[Role](1)
    fmt.Println(ok) // Output: true
    fmt.Println(r1) // Output: admin

    // Parse an enum from string.
    r2, ok := enum.FromString[Role]("admin")
    fmt.Println(ok) // Output: true
    fmt.Println(r2) // Output: admin

    // Now you can use json.Marshal instead of enum.MarshalJSON.
    data, err := json.Marshal(RoleUser)
    fmt.Println(err)          // Output: nil
    fmt.Println(string(data)) // Output: "user"
}

WrapEnum ist die am besten geeignete Aufzählung für allgemeine Fälle. Es bietet jedoch nur grundlegende Typsicherheit. Wenn Sie eine strengere Lösung wünschen, sollten Sie SafeEnum verwenden.

// WrapEnum cannot prevent this type of invalid declaration.
// Consider using SafeEnum.
r := Role(42)

SafeEnum

SafeEnum definiert eine starke typsichere Aufzählung. Wie WrapEnum bietet es eine Reihe integrierter Methoden, um die Arbeit mit Aufzählungen zu vereinfachen.

Das SafeEnum erzwingt eine strenge Typsicherheit und stellt sicher, dass nur vordefinierte Enum-Werte zulässig sind. Es verhindert die versehentliche Erstellung neuer Enum-Typen und stellt einen garantierten Satz gültiger Werte bereit.

Vorteile?

• Bietet starke Typensicherheit.
• Bietet viele nützliche integrierte Methoden.
• Vollständige Serialisierungs- und Deserialisierungsunterstützung sofort einsatzbereit.

Nachteile ?

• Unterstützt keine konstanten Werte.

Warum ist ständige Unterstützung wichtig?

Einige statische Analysetools (z. B. nogo für bazel, golangci-lint mit erschöpfender Erweiterung) unterstützen die Überprüfung auf erschöpfende Switch-Anweisungen in konstanten Aufzählungen. Durch Auswahl einer Enumeration mit ständiger Unterstützung können Sie diese Funktionalität in diesen Tools aktivieren.

// Enum in Java
enum TrafficLight {
    RED, YELLOW, GREEN
}

Referenzen

xybor-x/enum: https://github.com/xybor-x/enum

Medium: https://medium.com/@huykingsofm/enum-handling-in-go-a2727154435e
Vietnamesisches Viblo: https://viblo.asia/p/cac-van-de-cua-go-enum-va-cach-giai-quyet-voi-xybor-xenum-Yym401A9J91

Das obige ist der detaillierte Inhalt vonGehen Sie zu den Problemen und Lösungen von Enum mit xybor-x/enum. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!