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

---