Les maps
C'est quoi une map?
Une map est un type builtin en Go qui associe une valeur à une clé. La valeur peut être extraite en utilisant la clé correspondante.
Comment créer une map?
Une map peut être créée en passant un type de clé et une variable à la fonction make. make(map[type of key]type of value) est le syntaxe pour créer une map.
personSalary := make(map[string]int)
La ligne ci-dessus crée une map nommé personSalary qui a comme clés les valeursstring et int.
La valeur nulle de map est nil. Il n'est pas possible d'ajouter des éléments à une map nil. Par conséquent, il faut initialiser map en utilisant la fonction make.
package main
import (
"fmt"
)
func main() {
var personSalary map[string]int
if personSalary == nil {
fmt.Println("map est nulle. on va créer une map.")
personSalary = make(map[string]int)
}
}
Dans le programme ci-dessus, personSalary est nil, par conséquent, elle va être initialisée en utilisant la fonction make, Le programme aura comme sortie map est nulle. on va créer une map.
Ajouter des éléments à une map
Le syntaxe pour ajouter de nouveaux éléments à une map est le même que d'un tableau. Le programme ci-dessus ajoute de nouveaux éléments à la map personSalary.
package main
import (
"fmt"
)
func main() {
personSalary := make(map[string]int)
personSalary["maria"] = 15000
personSalary["paul"] = 19000
personSalary["mike"] = 10000
fmt.Println("le contenu de la map personSalary:", personSalary)
}
Le programme ci-dessus affiche: le contenu de la map personSalary: map[maria:15000 paul:19000 mike:10000]
Il est aussi possible d'initialiser une map durant la déclaration.
package main
import (
"fmt"
)
func main() {
personSalary := map[string]int {
"maria": 15000,
"paul": 19000,
}
personSalary["mike"] = 10000
fmt.Println("le contenu de la map personSalary:", personSalary)
}
Après l'exécution du programme, on aura comme sortie:
le contenu de la map personSalary: map[maria:15000 jamie:19000 mike:10000]
L'accès aux éléments d'une map
le syntaxe map[key]sert à extraire les éléments d'une map.
package main
import (
"fmt"
)
func main() {
personSalary := map[string]int{
"maria": 15000,
"paul": 19000,
}
personSalary["mike"] = 10000
employee := "paul"
fmt.Println("Salaire de", employee, "est", personSalary[employee])
}
Après l'exécution du programme, on obtient comme sortie:Salaire de paul est 19000
Si un élément n'est pas présent ,la map va retourner la valeur zéro du type de l'élément.
Le syntaxe pour savoir si une clé est présente ou non dans une map est :
value, ok := map[key]
Si ok est true, alors le key(clé) est présent et sa valeur est présente dans la variable value, sinon le key(clé) est absent.
package main
import (
"fmt"
)
func main() {
personSalary := map[string]int{
"maria": 15000,
"paul": 19000,
}
personSalary["mike"] = 10000
newEmp := "donald"
value, ok := personSalary[newEmp]
if ok == true {
fmt.Println("Salaire de", newEmp, "est", value)
} else {
fmt.Println(newEmp,"n'existe pas")
}
}
la sortie du programme serait donald n'existe pas
La forme range d'une boucle for est utilisée pour itérer sur tous les éléments de la map.
package main
import (
"fmt"
)
func main() {
personSalary := map[string]int{
"maria": 15000,
"paul": 19000,
}
personSalary["mike"] = 10000
fmt.Println("tous les éléments de la map")
for key, value := range personSalary {
fmt.Printf("personSalary[%s] = %d\n", key, value)
}
}
La sortie du programme ci-dessus est comme suivante:
tous les éléments de la map
personSalary[mike] = 10000
personSalary[maria] = 15000
personSalary[paul] = 19000
L'extraction des valeurs d'une map en utilisant for range en gardant l'ordre n'est pas guarantie après chaque exécution du programme.
Suppression d'éléments
Le syntaxe pour supprimer key d'une map est delete(map, key). La fonction delete ne retourne aucune valeur.
package main
import (
"fmt"
)
func main() {
personSalary := map[string]int{
"maria": 15000,
"paul": 19000,
}
personSalary["mike"] =10000
fmt.Println("map avant suppression", personSalary)
delete(personSalary, "maria")
fmt.Println("map après suppression", personSalary)
}
Le programme ci-dessus va supprimer la clé "maria".
La longueur d'une map
La longueur d'une map peut être déterminée en utilisant la fonction len
package main
import (
"fmt"
)
func main() {
personSalary := map[string]int{
"maria": 15000,
"paul": 19000,
}
personSalary["mike"] = 10000
fmt.Println("longueur est", len(personSalary))
}
La longueur déterminée après l'exécution du programme est 3.
Les maps sont des types de référence
Quand une map est attribuée à une nouvelle variable, elles pointent toutes les deux sur la même structure de données interne. Par conséquent, un changement qui touche l'une d'elles va automatiquement toucher l'autre.
package main
import (
"fmt"
)
func main() {
personSalary := map[string]int{
"maria": 15000,
"paul": 15000,
}
personSalary["mike"] = 10000
fmt.Println("le salaire original de la personne", personSalary)
newPersonSalary := personSalary
newPersonSalary["mike"] = 18000
fmt.Println("le nouveau salaire de la personne ", personSalary)
}
L'égalité des maps
package main
func main() {
map1 := map[string]int{
"one": 1,
"two": 2,
}
map2 := map1
if map1 == map2 {
}
}
Le programme ci-dessus va lancer une erreur de compilation invalid operation: map1 == map2 (map can only be compared to nil).
Pour comparer deux maps, il faut comparer élément par élément des deux maps.
Posted on Utopian.io - Rewarding Open Source Contributors