Comment puis-je simuler efficacement des unions dans Go ?

Meilleures pratiques pour les syndicats en Go

Les syndicats sont un sujet controversé dans Go, car le langage ne les prend pas en charge nativement. Cependant, il existe de nombreuses situations dans lesquelles les unions sont nécessaires, ce qui amène les développeurs à trouver des moyens créatifs de contourner cette limitation.

Simulation des unions avec des structures de conteneur

Une approche courante consiste à créer une structure de conteneur qui détient les différents types qui seraient représentés dans le syndicat. Par exemple, pour une structure XML contenant des commentaires, des instructions de traitement ou des espaces, on pourrait définir une structure conteneur comme suit :

type Misc struct {
    value interface {}
}

Cette structure peut ensuite être utilisée pour contenir l'un des trois types :

func MiscComment(c *Comment) *Misc {
    return &Misc{c}
}

func MiscProcessingInstruction (pi *ProcessingInstruction) *Misc {
    return &Misc{pi}
}

func MiscWhiteSpace (ws *WhiteSpace) *Misc {
    return &Misc{ws}
}

Prédicats et getters

Pour déterminer le type de valeur stockée dans une structure Misc, les prédicats peuvent être utilisé :

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

func (m Misc) IsProcessingInstruction () bool {
    _, itis := m.value.(*ProcessingInstruction)
    return itis
}

func (m Misc) IsWhiteSpace () bool {
    _, itis := m.value.(*WhiteSpace)
    return itis
}

Les getters peuvent être utilisés pour récupérer les éléments correctement typés :

func (m Misc) Comment () *Comment {
    return m.value.(*Comment)
}

func (m Misc) ProcessingInstruction () *ProcessingInstruction {
    return m.value.(*ProcessingInstruction)
}

func (m Misc) WhiteSpace () *WhiteSpace {
    return m.value.(*WhiteSpace)
}

Sécurité des types et approches alternatives

Bien que cette approche fournisse un moyen de simuler syndicats, il n'assure pas la sécurité du type. Pour assurer la sécurité des types, on pourrait envisager de créer une interface qui marque quelque chose comme Misc :

type Misc interface {
    ImplementsMisc()
}

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

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

De cette façon, des fonctions peuvent être écrites qui ne gèrent que les objets Misc, et le type spécifique peut être déterminé plus tard.

Cependant, il est important de noter que l'imitation des syndicats dans Go nécessite une mise en œuvre minutieuse pour éviter un code dangereux. Si la sécurité des types est une priorité, des approches alternatives telles que le polymorphisme ou les génériques doivent être envisagées.

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!