Go-Map

Map ist eine ungeordnete Sammlung von Schlüssel-Wert-Paaren. In anderen Sprachen auch als Hash, Dictionary, HashMap bekannt.

Deklaration

Maps werden mit dem Schlüsselwort map deklariert. Das Format lautet wie folgt:

map[SchlüsselTyp]WertTyp

Beispiel:

var m map[string]int

Dies deklariert eine Map mit String-Schlüsseln und int-Werten.

Initialisierung

Eine Map muss initialisiert werden, bevor sie verwendet werden kann. Andernfalls ist sie nil und kann keine Elemente speichern.

m := make(map[string]int)

Oder mit Literal-Initialisierung:

m := map[string]int{
   "a": 1,
   "b": 2,
}

Operationen

Einfügen

m["Schlüssel"] = Wert

Beispiel:

m := make(map[string]int)
m["a"] = 1
m["b"] = 2

Abrufen

wert := m["Schlüssel"]

Beispiel:

m := map[string]int{
   "a": 1,
   "b": 2,
}
wert := m["a"]
fmt.Println(wert) // 1

Existenzprüfung

Um zu prüfen, ob ein Schlüssel in einer Map existiert, kann die folgende Syntax verwendet werden:

wert, ok := m["Schlüssel"]

Beispiel:

m := map[string]int{
   "a": 1,
   "b": 2,
}
wert, ok := m["a"]
if ok {
   fmt.Println("Schlüssel existiert:", wert)
} else {
   fmt.Println("Schlüssel existiert nicht")
}

Löschen

delete(m, "Schlüssel")

Beispiel:

m := map[string]int{
   "a": 1,
   "b": 2,
}
delete(m, "a")

TIP

Das Löschen eines nicht existierenden Schlüssels hat keine Auswirkung.

Länge

länge := len(m)

Beispiel:

m := map[string]int{
   "a": 1,
   "b": 2,
}
fmt.Println(len(m)) // 2

Iteration

Maps können mit range iteriert werden.

m := map[string]int{
   "a": 1,
   "b": 2,
   "c": 3,
}
for k, v := range m {
   fmt.Printf("Key: %s, Value: %d\n", k, v)
}

Ausgabe:

Key: a, Value: 1
Key: b, Value: 2
Key: c, Value: 3

TIP

Die Iterationsreihenfolge von Maps ist nicht garantiert. Bei jeder Iteration kann die Reihenfolge unterschiedlich sein.

nil Map

Eine nil Map kann keine Elemente speichern.

var m map[string]int
m["a"] = 1 // Panic!

Fehlermeldung:

panic: assignment to entry in nil map

Map von Maps

Maps können verschachtelt werden.

m := map[string]map[string]int{
   "a": {
      "x": 1,
      "y": 2,
   },
   "b": {
      "z": 3,
   },
}
fmt.Println(m["a"]["x"]) // 1

Vergleichbarkeit

Map-Schlüssel müssen vergleichbar sein. Das heißt, sie müssen mit == verglichen werden können. Daher können Slices, Maps und Funktionen nicht als Schlüssel verwendet werden.

m := map[[2]int]int{
   {1, 2}: 1,
   {3, 4}: 2,
}
fmt.Println(m[[2]int{1, 2}]) // 1

Concurrent Map

Maps sind nicht threadsicher. Bei gleichzeitiger Verwendung müssen Sie eine Synchronisationsmethode verwenden, z. B. sync.Mutex oder sync.Map.

var mu sync.Mutex
m := make(map[string]int)

mu.Lock()
m["a"] = 1
mu.Unlock()

Oder verwenden Sie sync.Map:

var m sync.Map
m.Store("a", 1)
wert, ok := m.Load("a")