Comme indiqué dans d'autres réponses, la solution générale consiste à utiliser une expression d'index dans une affectation du formulaire spécial:
v, ok = a[x]
v, ok := a[x]
var v, ok = a[x]
var v, ok T = a[x]
C'est agréable et propre. Il a cependant quelques restrictions: il doit s'agir d'une cession de forme spéciale. L'expression de droite doit être uniquement l'expression d'index de mappage et la liste des expressions de gauche doit contenir exactement 2 opérandes, le premier auquel le type de valeur est attribuable et le second auquel une bool
valeur est attribuable. La première valeur du résultat de ce formulaire spécial sera la valeur associée à la clé, et la deuxième valeur indiquera s'il existe réellement une entrée dans la carte avec la clé donnée (si la clé existe dans la carte). La liste des expressions de gauche peut également contenir l' identifiant vide si l'un des résultats n'est pas nécessaire.
Il est important de savoir que si la valeur de carte indexée nil
contient ou ne contient pas la clé, l'expression d'index est évaluée à la valeur zéro du type de valeur de la carte. Ainsi, par exemple:
m := map[int]string{}
s := m[1] // s will be the empty string ""
var m2 map[int]float64 // m2 is nil!
f := m2[2] // f will be 0.0
fmt.Printf("%q %f", s, f) // Prints: "" 0.000000
Essayez-le sur le Go Playground .
Donc, si nous savons que nous n'utilisons pas la valeur zéro dans notre carte, nous pouvons en profiter.
Par exemple, si le type de valeur est string
, et nous savons que nous ne stockons jamais d'entrées dans la carte où la valeur est la chaîne vide (valeur nulle pour le string
type), nous pouvons également tester si la clé est dans la carte en comparant les non spéciales forme de (résultat de) l'expression d'index à la valeur zéro:
m := map[int]string{
0: "zero",
1: "one",
}
fmt.Printf("Key 0 exists: %t\nKey 1 exists: %t\nKey 2 exists: %t",
m[0] != "", m[1] != "", m[2] != "")
Sortie (essayez-la sur le Go Playground ):
Key 0 exists: true
Key 1 exists: true
Key 2 exists: false
Dans la pratique, il existe de nombreux cas où nous ne stockons pas la valeur zéro dans la carte, donc cela peut être utilisé assez souvent. Par exemple, les interfaces et les types de fonctions ont une valeur nulle nil
, que nous ne stockons souvent pas dans les cartes. Il est donc possible de tester si une clé se trouve dans la carte en la comparant à nil
.
L'utilisation de cette "technique" présente également un autre avantage: vous pouvez vérifier l'existence de plusieurs clés de manière compacte (vous ne pouvez pas le faire avec le formulaire spécial "virgule ok"). En savoir plus: Vérifiez si la clé existe dans plusieurs cartes dans une seule condition
L'obtention de la valeur zéro du type de valeur lors de l'indexation avec une clé non existante nous permet également d'utiliser des cartes avec des bool
valeurs de manière pratique sous forme d' ensembles . Par exemple:
set := map[string]bool{
"one": true,
"two": true,
}
fmt.Println("Contains 'one':", set["one"])
if set["two"] {
fmt.Println("'two' is in the set")
}
if !set["three"] {
fmt.Println("'three' is not in the set")
}
Il sort (essayez-le sur le Go Playground ):
Contains 'one': true
'two' is in the set
'three' is not in the set
Voir aussi: Comment puis-je créer un tableau contenant des chaînes uniques?