Vérifier l'appartenance

Fait partie de la section Logique & Flux du Journey GO de Coddy. Leçon 34 sur 68.

Maintenant que vous pouvez ajouter des éléments à votre ensemble, l’opération essentielle suivante consiste à vérifier si un élément spécifique existe dans l’ensemble. C’est là que l’idiome « comma ok » de Go devient particulièrement utile.

Pour vérifier si un élément existe dans votre ensemble, vous utilisez la même syntaxe que pour vérifier la présence d’une clé dans une map :

_, ok := colors["red"]
if ok {
    fmt.Println("Red is in the set")
} else {
    fmt.Println("Red is not in the set")
}

Le trait de soulignement _ est utilisé parce que la valeur réelle ne nous importe pas (il s’agit toujours d’une structure vide). Nous nous intéressons uniquement à la variable booléenne ok, qui nous indique si la clé existe.

Vous pouvez également utiliser directement ce modèle dans une instruction if pour obtenir un code plus concis :

if _, exists := colors["blue"]; exists {
    fmt.Println("Blue is in the set")
}

Ce test d’appartenance est rapide et efficace, car il exploite l’implémentation optimisée des map de Go pour vous offrir les avantages en termes de performances d’une véritable structure de données d’ensemble.

Défi

Facile

Construisez un système de vérification des membres d’une équipe qui vérifie si certaines personnes font partie d’une équipe de projet en utilisant l’idiome des ensembles de Go. Ce défi montre comment utiliser l’idiome comma ok pour tester l’appartenance à un ensemble.

Vous recevrez deux entrées :

Une chaîne contenant les membres de l’équipe, séparés par des virgules (par exemple, "Alice,Bob,Charlie,Diana,Eve")
Une chaîne contenant les personnes à vérifier, séparées par des virgules (par exemple, "Bob,Frank,Alice,Grace,Charlie")

Votre tâche consiste à :

Créer un ensemble à l’aide de l’idiome Go map[string]struct{} pour stocker les membres de l’équipe
Analyser la première chaîne d’entrée en la divisant au niveau des virgules afin d’obtenir les noms individuels des membres de l’équipe
Ajouter chaque membre de l’équipe à votre ensemble en utilisant le littéral de structure vide {} comme valeur
Analyser la deuxième chaîne d’entrée en la divisant au niveau des virgules afin d’obtenir la liste des personnes à vérifier
Pour chaque personne à vérifier, utiliser l’idiome comma ok _, ok := teamSet[person] pour tester son appartenance
Afficher les résultats de la vérification pour chaque personne vérifiée :
- Si la personne fait partie de l’équipe : "[person] is on the team"
- Si la personne ne fait pas partie de l’équipe : "[person] is not on the team"
Après avoir vérifié toutes les personnes, afficher un résumé :
- "Team size: [team_member_count]"
- "People checked: [people_checked_count]"
- "Team members found: [found_count]"
- "Non-team members: [not_found_count]"

Utilisez le paquet strings pour diviser les chaînes d’entrée au niveau des virgules. Ce défi montre comment l’idiome comma ok fournit un moyen sûr et efficace de vérifier l’appartenance à un ensemble Go, en renvoyant à la fois la valeur et un booléen indiquant si la clé existe.

Essayez vous-même

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Lire l'entrée
	var teamMembersInput string
	var peopleToCheckInput string
	fmt.Scanln(&teamMembersInput)
	fmt.Scanln(&peopleToCheckInput)
	
	// Analyser les chaînes d'entrée
	teamMembers := strings.Split(teamMembersInput, ",")
	peopleToCheck := strings.Split(peopleToCheckInput, ",")
	
	// TODO: Écrivez votre code ci-dessous
	// Créer un ensemble en utilisant map[string]struct{}
	// Ajouter les membres de l'équipe à l'ensemble
	// Vérifier chaque personne en utilisant l'idiome comma ok
	// Afficher les résultats de vérification et le résumé
	
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logique & Flux

Entraînez-vous par vous-même : Compilateur Go en ligne