Dans GO, il n'y a pas de type d'ensemble intégré, mais un ensemble peut être implémenté efficacement à l'aide d'une carte avec des valeurs struct {} pour minimiser l'utilisation de la mémoire. 1. Utilisez une carte [t] struct {} pour représenter un ensemble où les touches sont les éléments. 2. Effectuez des opérations Ajouter en attribuant une clé à struct {}. 3. Vérifiez l'existence en utilisant l'idiome de virgule. 4. Retirez les éléments avec delete (). 5. Emballage des opérations dans des fonctions d'assistance ou des types comme STRINGSET pour la lisibilité. 6. Pour que la concurrence, utilisez une structure protégé par mutex ou Sync.map. 7. Utiliser éventuellement des packages tiers comme Golang-Set pour les fonctionnalités avancées au prix de certains types de sécurité et de performances. Cette approche offre une fa?on simple, efficace et flexible de travailler avec des ensembles en Go.

Dans GO, il n'y a pas de type set intégré, mais l'implémentation d'un est simple à l'aide d'une carte. L'idée est d'utiliser les clés d'une carte pour représenter les éléments de l'ensemble, et comme nous ne nous soucions pas des valeurs, nous pouvons utiliser une struct{} pour maintenir l'utilisation de la mémoire minimale.

Utilisation d'une carte comme ensemble

La fa?on la plus courante d'implémenter un ensemble dans GO consiste à utiliser une map[T]struct{} . Cela exploite l'efficacité des cartes pour les recherches, les insertions et les suppressions, qui sont toutes O (1) en moyenne.

Par exemple:

 set: = make (map [string] struct {})
set ["a"] = struct {} {}
set ["b"] = struct {} {}

Pour vérifier si un élément existe:

 Si _, existe: = set ["a"]; existe {
    // "A" est dans l'ensemble
}

Pour supprimer un élément:

 supprimer (set, "a")

Cette approche fonctionne pour tout type comparable - cha?nes, entiers, structures (tant qu'ils ne contiennent que des champs comparables), etc.

Opérations de base

Voici quelques opérations communes que vous voudrez peut-être dans un ensemble:

• Ajouter : insérer un nouvel élément
• Supprimer : supprimer un élément existant
• Contient : Vérifiez si un élément existe
• Taille : Obtenez le nombre d'éléments
• Effacer : supprimer tous les éléments

Vous pouvez les envelopper dans un alias de type et des fonctions d'assistance pour une meilleure lisibilité et réutilisabilité.

Exemple:

 Tapez la carte de la stringset [String] struct {}

func (s stringset) add (valeur de valeur) {
    s [valeur] = struct {} {}
}

func (s stringset) contient (valeur de valeur) bool {
    _, existe: = s [valeur]
    Le retour existe
}

Cela rend votre code plus propre et vous donne une interface plus intuitive avec laquelle travailler.

Manipulation de la sécurité du fil (facultatif)

Si vous travaillez dans un environnement simultanée, la carte intégrée n'est pas un thread-safe. Vous devrez donc ajouter un mutex pour protéger l'accès.

Vous pouvez le faire en définissant une structure qui comprend une carte et un mutex:

 Type concurrentSet struct {
    m map [String] struct {}
    mu sync.mutex
}

func (cs * concurrentSet) add (valeur de valeur) {
    cs.mu.lock ()
    différer cs.mu.unlock ()
    cs.m [valeur] = struct {} {}
}

func (cs * concurrentSet) contient (valeur de valeur) bool {
    cs.mu.lock ()
    différer cs.mu.unlock ()
    _, existe: = cs.m [valeur]
    Le retour existe
}

Cela garantit un accès s?r à partir de plusieurs goroutins, mais il est livré avec un petit co?t de performance. Utilisez-le uniquement si la concurrence est nécessaire.

Envisagez d'utiliser un package d'aide

Bien qu'il soit facile de lancer votre propre ensemble de base, certains développeurs préfèrent utiliser des packages bien testés comme golang-set , qui fournit une interface plus riche en fonctionnalités et générique.

Ces packages soutiennent souvent des opérations comme l'union, l'intersection et la différence hors de la bo?te. Mais gardez à l'esprit qu'ils s'appuient généralement sur l'interface {} et les assertions de type, qui peuvent être moins performantes et s?rs de type que l'utilisation de cartes natives.

Donc si vous voulez:

• Simplicité et sécurité de type → coller avec un ensemble basé sur la carte native
• Opérations de set avancé → Considérons un package tiers
• Accès simultané → Enveloppez votre ensemble avec un mutex ou utilisez une synchronisation

C'est le c?ur de la fa?on de travailler avec des ensembles dans Go. Ce n'est pas sophistiqué, mais l'utilisation de cartes vous donne une solution solide, lisible et efficace.

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!