Problèmes et solutions de Go Enum avec xybor-x/enum

Qu'est-ce qu'une énumération ?

Une énumération, abréviation de énumération, est un type de données spécial qui représente un ensemble de valeurs nommées. Il est utilisé pour définir une collection de valeurs constantes conceptuellement liées, améliorant la lisibilité du code et réduisant les erreurs causées par l'utilisation de valeurs littérales arbitraires.

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

# Enum in Python
from enum import Enum

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

Énumération en Go

Go ne prend pas en charge l'énumération de manière native. Cependant, il existe un moyen populaire de définir une énumération dans Go : utiliser l'approche iota.

package main

type TrafficLight int

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

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

Cependant, il y a quelques problèmes lorsque l'on traite l'énumération de cette manière :

• Manque de méthodes intégrées : aucune prise en charge directe de fonctionnalités telles que la liste de toutes les valeurs d'énumération ou la conversion entre chaînes et énumérations.
• Sécurité des types limitée : les énumérations sont généralement représentées à l'aide de types de base (par exemple, int ou string), ce qui augmente le risque d'affectations involontaires.
• Complexité de la sérialisation et de la désérialisation : le mappage d'énumérations vers et depuis des formats comme JSON nécessite une gestion supplémentaire.

La bibliothèque xybor-x/enum

La bibliothèque xybor-x/enum fournit des solutions élégantes, faciles à utiliser et puissantes pour Go enum sans génération de code.

Il existe certains types d'énumérations avec lesquels vous pouvez travailler xybor-x/enum, veuillez choisir celui qui convient le mieux.

Énumération de base

Pour ?

• Simple.
• Prend en charge les valeurs constantes.

Inconvénients ?

• Aucune méthode intégrée.
• Aucune sécurité de type.
• Manque de prise en charge de la sérialisation et de la désérialisation. Comme l’énumération traditionnelle, l’énumération de base n’a pas de méthode intégrée. Mais vous pouvez utiliser les fonctions utilitaires de xybor-x/enum pour gérer ce type d'énumération.

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

Pour ?

• Prend en charge les valeurs constantes.
• Fournit de nombreuses méthodes intégrées utiles.
• Prise en charge complète de la sérialisation et de la désérialisation.

Inconvénients ?

• Fournit uniquement une sécurité de type de base.

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 est l'énumération la plus appropriée pour les cas généraux. Cependant, il n’offre qu’une sécurité de type de base. Si vous en voulez un plus strict, pensez à utiliser SafeEnum.

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

SafeEnum

SafeEnum définit une énumération de type sécurisé forte. Comme WrapEnum, il fournit un ensemble de méthodes intégrées pour simplifier le travail avec les énumérations.

Le SafeEnum applique une sécurité de type stricte, garantissant que seules les valeurs d'énumération prédéfinies sont autorisées. Il empêche la création accidentelle de nouveaux types d'énumération, fournissant un ensemble garanti de valeurs valides.

Pour ?

• Fournit une forte sécurité de type.
• Fournit de nombreuses méthodes intégrées utiles.
• Prise en charge complète de la sérialisation et de la désérialisation.

Inconvénients ?

• Ne prend pas en charge les valeurs constantes.

Pourquoi un soutien constant est-il important ?

Certains outils d'analyse statique (tels que nogo pour bazel, golangci-lint avec extension exhaustive) prennent en charge la vérification des instructions switch exhaustives dans les énumérations constantes. En choisissant une énumération avec un support constant, vous pouvez activer cette fonctionnalité dans ces outils.

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

Références

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

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!