Итак, Go предоставляет встроенный тип карты, и мы научимся им пользоваться.

Но вопрос в том, что такое карты? И зачем они нам нужны?

Карта — это неупорядоченная коллекция пар ключ-значение. Она сопоставляет ключи со значениями. Ключи уникальны в пределах карты, а значения могут быть не уникальны.

Она используется для быстрого поиска, извлечения и удаления данных на основе ключей. Это одна из наиболее часто используемых структур данных.

Декларация

Давайте начнем с объявления.

Карта объявляется с помощью следующего синтаксиса:

var m map[K]V

Где K — это тип ключа, а V — тип значения.

Например, вот как мы можем объявить карту ключей string в значения int.

func main() {
    var m map[string]int

    fmt.Println(m)
}

$ go run main.go
nil

Как мы видим, нулевым значением карты является nil.

Карта nil не имеет ключей. Более того, любая попытка добавить ключи в карту nil приведет к ошибке во время выполнения.

Инициализация

Существует несколько способов инициализации карты.

функция make

Мы можем использовать встроенную функцию make, которая выделяет память для ссылающихся типов данных и инициализирует их базовые структуры данных.

func main() {
    var m = make(map[string]int)

    fmt.Println(m)
}

$ go run main.go
map[]

литерал карты

Другой способ — использование литерала карты.

func main() {
    var m = map[string]int{
        "a": 0,
    "b": 1,
    }

    fmt.Println(m)
}

Обратите внимание, что последняя запятая необходима

$ go run main.go
map[a:0 b:1]

Как всегда, мы можем использовать и наши пользовательские типы.

type User struct {
    Name string
}

func main() {
    var m = map[string]User{
        "a": User{"Peter"},
        "b": User{"Seth"},
    }

    fmt.Println(m)
}

Мы можем даже удалить тип значения, и Go сам разберется!

var m = map[string]User{
    "a": {"Peter"},
    "b": {"Seth"},
}

$ go run main.go
map[a:{Peter} b:{Seth}]

Добавить

Теперь давайте посмотрим, как мы можем добавить значение к нашей карте.

func main() {
    var m = map[string]User{
        "a": {"Peter"},
        "b": {"Seth"},
    }

    m["c"] = User{"Steve"}

    fmt.Println(m)
}

$ go run main.go
map[a:{Peter} b:{Seth} c:{Steve}]

Извлечение

Мы также можем получить наши значения из карты с помощью клавиши.

...
c := m["c"]
fmt.Println("Key c:", c)

$ go run main.go
key c: {Steve}

Что если мы используем ключ, которого нет на карте?

...
d := m["d"]
fmt.Println("Key d:", d)

Да, вы угадали! Мы получим нулевое значение типа значения карты.

$ go run main.go
Key c: {Steve}
Key d: {}

Exists

Когда вы получаете значение, присвоенное данной клавише, возвращается также дополнительное булево значение. Булева переменная будет true, если ключ существует, и false в противном случае.

Давайте попробуем это сделать на примере:

...
c, ok := m["c"]
fmt.Println("Key c:", c, ok)

d, ok := m["d"]
fmt.Println("Key d:", d, ok)

$ go run main.go
Key c: {Steve} Present: true
Key d: {} Present: false

Обновление

Мы также можем обновить значение для клавиши, просто переназначив ее.

...
m["a"] = "Roger"

$ go run main.go
map[a:{Roger} b:{Seth} c:{Steve}]

Удаление

Или мы можем удалить ключ с помощью встроенной функции delete.

Вот как выглядит синтаксис:

...
delete(m,

Первый аргумент — это карта, а второй — клавиша, которую мы хотим удалить.

Функция delete() не возвращает никакого значения. Также она ничего не делает, если ключ не существует в карте.

$ go run main.go
map[a:{Roger} c:{Steve}]

Итерация

Подобно массивам или срезам, мы можем выполнять итерацию по картам с помощью ключевого слова range.

package main

import "fmt"

func main() {
    var m = map[string]User{
        "a": {"Peter"},
        "b": {"Seth"},
    }

    m["c"] = User{"Steve"}

    for key, value := range m {
        fmt.Println("Key: %s, Value: %v", key, value)
    }
}

$ go run main.go
Key: c, Value: {Steve}
Key: a, Value: {Peter}
Key: b, Value: {Seth}

Обратите внимание, что карта — это неупорядоченная коллекция, и поэтому порядок итерации карты не гарантированно будет одинаковым при каждом итерации.

Свойства

Наконец, давайте поговорим о свойствах карты.

Карты являются ссылочными типами, а это значит, что когда мы присваиваем карту новой переменной, они обе ссылаются на одну и ту же базовую структуру данных.

Поэтому изменения, сделанные в одной переменной, будут видны в другой.

package main

import "fmt"

type User struct {
    Name string
}

func main() {
    var m1 = map[string]User{
        "a": {"Peter"},
        "b": {"Seth"},
    }

    m2 := m1
    m2["c"] = User{"Steve"}

    fmt.Println(m1) // Output: map[a:{Peter} b:{Seth} c:{Steve}]
    fmt.Println(m2) // Output: map[a:{Peter} b:{Seth} c:{Steve}]
}

Эта статья является частью моего открытого курса по Go, доступного на Github.