Go Academy · Leçon

Les maps comme ensembles

Utiliser des maps pour stocker des valeurs uniques

Les maps comme ensembles est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Go n'a pas de type ensemble

Go ne possède pas de type ensemble intégré. La manière idiomatique de représenter un ensemble de valeurs uniques consiste à utiliser une table associative dont les clés sont les éléments de l'ensemble.

Table associative de booléens

Une possibilité consiste à utiliser map[string]bool. La présence d'une clé (avec la valeur true) signifie que l'élément appartient à l'ensemble.

package main

import "fmt"

func main() {
	set := map[string]bool{}
	set["apple"] = true
	set["banana"] = true
	fmt.Println(set)
}

Vérifier l'appartenance

Utilisez l'idiome virgule-vérification ou lisez directement le booléen pour vérifier l'appartenance.

package main

import "fmt"

func main() {
	set := map[string]bool{"apple": true}
	fmt.Println(set["apple"])
	fmt.Println(set["cherry"])
}

Table associative de structures vides

Un ensemble plus économe en mémoire utilise map[string]struct{}. Une structure vide occupe zéro octet : seules les clés sont donc stockées.

package main

import "fmt"

func main() {
	set := map[string]struct{}{}
	set["x"] = struct{}{}
	_, ok := set["x"]
	fmt.Println("x in set:", ok)
}

Pourquoi une structure vide

Dans un ensemble, la valeur n'a aucune importance ; seule la clé compte. struct{}{} indique que vous avez l'intention d'ignorer les valeurs et n'utilise pas de mémoire supplémentaire pour chaque entrée.

Ajouter des éléments

L'ajout d'une clé en double n'a aucun effet : l'ensemble garantit donc naturellement l'unicité.

package main

import "fmt"

func main() {
	set := map[string]struct{}{}
	set["a"] = struct{}{}
	set["a"] = struct{}{}
	fmt.Println("size:", len(set))
}

Supprimer les doublons

Un usage classique consiste à dédupliquer une tranche. Ajoutez chaque élément à un ensemble, puis récupérez les clés uniques.

package main

import "fmt"

func main() {
	input := []string{"a", "b", "a", "c", "b"}
	set := map[string]struct{}{}
	for _, v := range input {
		set[v] = struct{}{}
	}
	fmt.Println("unique count:", len(set))
}

Construire une tranche unique

Combinez l'ensemble avec une tranche résultat pour conserver l'ordre de première apparition tout en supprimant les doublons.

package main

import "fmt"

func main() {
	input := []int{1, 2, 1, 3, 2}
	seen := map[int]struct{}{}
	result := []int{}
	for _, v := range input {
		if _, ok := seen[v]; !ok {
			seen[v] = struct{}{}
			result = append(result, v)
		}
	}
	fmt.Println(result)
}

Intersection d'ensembles

Pour trouver les éléments communs à deux ensembles, parcourez l'un d'eux et conservez ceux qui sont présents dans l'autre.

package main

import "fmt"

func main() {
	a := map[int]struct{}{1: {}, 2: {}, 3: {}}
	b := map[int]struct{}{2: {}, 3: {}, 4: {}}
	for k := range a {
		if _, ok := b[k]; ok {
			fmt.Println("common:", k)
		}
	}
}

Supprimer un élément d'un ensemble

Utilisez delete pour retirer un élément de l'ensemble.

package main

import "fmt"

func main() {
	set := map[string]struct{}{"a": {}, "b": {}}
	delete(set, "a")
	_, ok := set["a"]
	fmt.Println("a in set:", ok)
}

Choisir entre bool et struct{}

Les deux solutions fonctionnent. Utilisez map[T]bool lorsque la lisibilité de set[x] en tant que booléen est utile. Utilisez map[T]struct{} lorsque vous voulez signaler que la valeur n'a pas d'importance et économiser de la mémoire dans les grands ensembles.

Vérification rapide

Pourquoi map[string]struct{} est-il souvent préféré à map[string]bool pour représenter des ensembles ?

Récapitulatif

Les tables associatives comme ensembles :

Go n'a pas de type ensemble ; utilisez une table associative indexée par les éléments
map[T]bool ou map[T]struct{}
Elles sont très utiles pour la déduplication et les vérifications d'appartenance

Questions Fréquemment Posées

La leçon « Les maps comme ensembles » est-elle gratuite ?

Oui — le texte complet de « Les maps comme ensembles » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Les maps comme ensembles » ?

Utiliser des maps pour stocker des valeurs uniques Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Les maps comme ensembles » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy