On commence par créer un dictionnaire vide en précisant le type des clés et le type des valeurs.

m := make(map[string]int)

Dans ce cas `m` sera un dictionnaire dont les clés sont des chaînes de caractères et les valeurs sont des entiers.

Ensuite on peut ajouter des paires clé - valeur :

m["chien"] = 4
m["poule"] = 2
m["escargot"] = 1

La fonction len renvoie le nombre de paires.

La fonction delete supprime une paire

delete(m, "chien")

La lecture d'une valeur est habituel :

x := m["poule"]
// x est initialisé avec la valeur 2

Prenons le code suivant

package main

import "fmt"

func main() {
    fmt.Println("Hello, playground")
    m:= make(map[string]int)
    m["chien"] = 4
    m["serpent"] = 0
    var x int = m["chien"]
    var y int = m["lapin"]
    var z int = m["serpent"]
    fmt.Println(x)
    fmt.Println(y)
    fmt.Println(z)
}

"chien" est présent dans le dictionnaire, x prendra donc la valeur 4 . z de la même façon devrait prendre la valeur 0.

Mais qu'en est-il de y ?

Il n'y aura pas d'erreur. y recevra une valeur nulle par défaut. Si les valeurs avaient étaient été de type string, y aurait reçu "", un texte vide. Comme le tableau contient des entiers, y reçoit une valeur nulle. Donc y reçoit 0.

Ce mécanisme évite les erreurs mais peut-être ennuyeux car il ne permet pas de distinguer le vrai 0 présent dans le dictionnaire pour "serpent" et le faux 0 qui ne correspond à rien dans le dictionnaire…

Si on a besoin de lever le doute, un mécanisme existe :

var y, p := m["lapin"]

la lecture dans le dictionnaire renvoie ici deux résultats, une valeur pour y qui dans ce cas est un 0 par défaut vu que "lapin" n'est pas dans le dictionnaire, et un booléen qui indique si la clé a été trouvée. Ici, p sera false vu que “lapin” n'était pas dans le dictionnaire.