Comment les développeurs Go peuvent-ils gérer efficacement les syndicats sans support intégré ?

Gérer les syndicats dans Go : une enquête sur les meilleures pratiques

Go ne dispose pas de types de syndicats intégrés, ce qui peut constituer un inconvénient dans certains scénarios . Par exemple, lorsqu'ils traitent de l'utilisation des unions par XML, les développeurs Go doivent trouver des solutions alternatives.

Une approche courante consiste à créer une structure de conteneur pour contenir les différents types pouvant constituer l'union. Cependant, cette approche peut conduire à un code volumineux avec des fonctions et des méthodes redondantes.

Dans cet article, nous explorons s'il existe de meilleures façons de gérer les unions dans Go.

La solution actuelle : Code redondant

Prenons l'exemple de la modélisation du non-terminal Misc de XML, qui peut être un commentaire, une instruction de traitement ou du blanc espace. L'implémentation du code Go pour cette union à l'aide d'une structure de conteneur nécessite l'écriture de constructeurs, de getters et de prédicats pour chaque type :

type Misc struct {
    value interface{}
}

func MiscComment(c *Comment) *Misc { return &Misc{c} }
func MiscProcessingInstruction(pi *ProcessingInstruction) *Misc { return &Misc{pi} }
func MiscWhiteSpace(ws *WhiteSpace) *Misc { return &Misc{ws} }

func (m Misc) IsComment() bool { _, ok := m.value.(*Comment); return ok }
func (m Misc) Comment() *Comment { return m.value.(*Comment) }

Cette solution est verbeuse et répétitive. Il lui manque la simplicité et l'élégance souvent associées au Go.

Approches alternatives

Commutateur de type :

Volker a proposé un type switch comme alternative viable :

switch v := m.value.(type) {
    case *Comment: // Type-assert v if needed
    // ...
}

Bien que le commutateur de type réduise le code répétitif, il lui manque encore sécurité des types appliquée par le compilateur.

Marquage de l'interface :

Une solution potentielle consiste à créer une interface qui identifie quelque chose comme un élément Divers :

type Misc interface {
    ImplementsMisc()
}

type Comment Chars
func (c Comment) ImplementsMisc() {}

type ProcessingInstruction
func (p ProcessingInstruction) ImplementsMisc() {}

Cette approche permet la création de fonctions qui gèrent uniquement les objets Divers, permettant la coercition de type à runtime :

func myFunc(m Misc) {
    switch m := m.(type) {
        case Comment: // Type-assert m if needed
        // ...
    }
}

Considérations et conclusions

Malgré le manque de types de syndicats intégrés dans Go, ces approches alternatives fournissent des solutions pour gérer les syndicats. Bien que l’approche de structure de conteneur reproduise les unions de style Java, elle nécessite davantage d’efforts de codage. L'approche du commutateur de type est plus simple, gérant les unions au moment de l'exécution mais avec une sécurité de type réduite. Enfin, l'approche de l'interface offre un compromis entre la sécurité des types et la simplicité du code.

L'approche la plus appropriée dépend des exigences spécifiques et des compromis que le développeur est prêt à accepter.

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!