Об авторе

Ментор по Golang

Хочу 300к+ ЗП

Что такое map в Go
Зачем нужны map в Golang
Как создать map в Go
nil map в Go: почему читать можно, а писать нельзя
Как получить значение из map: golang map get
golang map delete: как удалить ключ
Какие типы можно использовать как ключ map
Как map устроена под капотом до Go 1.24
Map и конкурентность: почему concurrent map writes падает
golang sync map: когда использовать sync.Map
Частые ошибки с map в Go

Map в Go: как работает мапа Golang, зачем нужен make, почему nil map паникует и что изменилось в Go 1.24

Zero Values в Go: что это такое, зачем нужны и где чаще всего ошибаются

Map в Go — это структура данных, где каждое значение лежит по своему ключу.

Проще на примере. Представь, у тебя есть список пользователей:

[]User{...}

Чтобы найти пользователя по ID, тебе придётся пройтись по всему списку.

А теперь представь, что ты заранее разложил их так:

users := map[int]string{
    1: "Niyaz",
    2: "Mark",
}

Теперь ты просто пишешь users[1] и сразу получаешь нужное значение.

То есть map решает конкретную задачу: быстро получить данные по ключу без перебора.

В отличие от slice, где доступ идёт по индексу, в map важен не порядок, а сам ключ. Ты не перебираешь данные, а сразу обращаешься к нужному значению.

Простой пример:

users := map[int]string{
    1: "Niyaz",
    2: "Mark",
}

fmt.Println(users[1]) // Niyaz

Map в Go обычно проходят быстро. Объявили map[string]int, положили значение по ключу, прочитали, удалили через delete и пошли дальше. На первых задачах кажется, что тема простая.

Проблемы начинаются позже.

Сначала ловишь panic: assignment to entry in nil map. Потом не понимаешь, почему range каждый раз отдаёт ключи в разном порядке. Потом кто-то на собеседовании спрашивает, почему нельзя взять адрес &m[key]. А потом в проде прилетает fatal error: concurrent map writes, и становится понятно, что map в Golang простая только снаружи.

В этой статье разберём map нормально: от базового синтаксиса до внутреннего устройства, роста, buckets, tophash, конкурентного доступа, sync.Map, копирования map и изменений в Go 1.24.

Статья подойдёт тем, кто изучает Golang с нуля, готовится к собеседованию по Go или уже пишет backend и хочет наконец закрыть тему мап без каши в голове.

Узнать подробнее

600+ записей собесов с идеальными ответами
прокачка Go в игровом формате (как Duolingo)
структурированная обновляемая база знаний по Go
комьюнити с быстрым фидбеком
практика и лекции, которые реально готовят к рынку

990 ₽/месяц

Закрытый IT-клуб ВЕКТОР: сообщество + приложение

Что такое map в Go

map в Go — это встроенная структура данных для хранения пар ключ-значение. По смыслу она похожа на hash table, dictionary или associative array в других языках.

Пример:

ages := map[string]int{
    "Niyaz": 30,
    "Mark":  24,
}

fmt.Println(ages["Niyaz"]) // 30

Ключом здесь выступает строка, значением — число. По ключу можно быстро получить значение, обновить его или удалить.

Общий вид типа:

map[KeyType]ValueType

Например:

map[string]int
map[int]string
map[string][]int
map[UserID]User
map[Point]bool

Ключ KeyType должен быть сравнимым типом. Значение ValueType может быть почти любым: числом, строкой, структурой, слайсом, другой map, указателем, интерфейсом.

Зачем нужны map в Golang

Map используют там, где нужно быстро находить данные по ключу.

Типичные случаи:

посчитать частоту слов в строке
хранить пользователей по ID
сделать set через map[string]bool или map[string]struct{}
сгруппировать элементы по признаку
хранить кеш
построить индекс для быстрого поиска
собрать данные из slice в map для дальнейшей обработки

Пример подсчёта слов:

words := []string{"go", "map", "go", "slice", "map", "go"}
counts := make(map[string]int)

for _, word := range words {
    counts[word]++
}

fmt.Println(counts) // map[go:3 map:2 slice:1]

Здесь работает важная особенность Go map: если ключа ещё нет, чтение вернёт zero value для типа значения. Для int это 0, поэтому counts[word]++ работает даже для нового слова.

Как создать map в Go

Есть три основных способа создать map.

Через make

Самый частый вариант:

m := make(map[string]int)

m["go"] = 1
fmt.Println(m["go"])

make создаёт и инициализирует внутреннюю hash table. После этого в map можно писать.

Такой запрос часто ищут как golang make map, new map in golang, новая map в golang.

Через литерал

Если значения известны заранее, удобнее использовать map literal:

statusCodes := map[int]string{
    200: "OK",
    404: "Not Found",
    500: "Internal Server Error",
}

Можно создать и пустую map:

m := map[string]int{}

Она уже инициализирована, в неё можно писать.

С hint по размеру

Если заранее понятно, сколько примерно элементов будет в map, можно передать hint:

users := make(map[int]User, 10_000)

Это не точная длина, а подсказка рантайму. Go заранее выделит больше места, чтобы map реже росла при вставках.

Важно не путать:

len(users) // количество элементов, а не capacity

У map нет cap, как у slice. Второй аргумент в make(map[K]V, n) — именно hint, а не длина.

nil map в Go: почему читать можно, а писать нельзя

Zero value для map — nil.

var m map[string]int
fmt.Println(m == nil) // true

Из nil map можно читать:

var m map[string]int

fmt.Println(m["missing"]) // 0
fmt.Println(len(m))        // 0

for k, v := range m {
    fmt.Println(k, v)      // не выполнится ни разу
}

Но писать в nil map нельзя:

var m map[string]int
m["go"] = 1 // panic: assignment to entry in nil map

Это одна из самых частых ошибок у новичков.

Правильно:

m := make(map[string]int)
m["go"] = 1

Или так:

m := map[string]int{}
m["go"] = 1

Запомнить можно просто: nil map ведёт себя как пустая при чтении, но не готова к записи.

Как получить значение из map: golang map get

Чтение значения делается через квадратные скобки:

score := users["alex"]

Если ключ есть, вернётся значение. Если ключа нет, Go вернёт zero value типа значения.

m := map[string]int{
    "a": 10,
}

fmt.Println(m["a"]) // 10
fmt.Println(m["b"]) // 0

И здесь появляется нюанс. Как понять, ключа нет или ключ есть, но значение равно zero value?

Например:

scores := map[string]int{
    "alex": 0,
}

fmt.Println(scores["alex"]) // 0
fmt.Println(scores["mark"]) // 0

В обоих случаях 0, но смысл разный.

Для этого есть форма с ok:

value, ok := scores["alex"]
if ok {
    fmt.Println("key exists", value)
} else {
    fmt.Println("key not found")
}

Если значение не нужно, а нужно только проверить ключ:

_, ok := scores["alex"]

Это базовый паттерн для golang map get и проверки ключей.

Как добавить и обновить значение в map

Добавление и обновление выглядят одинаково:

m := make(map[string]int)

m["go"] = 1     // добавили
m["go"] = 2     // обновили

Если ключа не было, он появится. Если был — значение заменится.

Для счётчиков часто используют инкремент:

views := make(map[string]int)
views["/blog/go-map"]++

Если ключа не было, чтение вернёт 0, потом ++ сделает 1.

golang map delete: как удалить ключ

Для удаления есть встроенная функция delete:

delete(m, "go")

Если ключа нет, ничего не произойдёт. Ошибки не будет.

m := map[string]int{
    "go": 1,
}

delete(m, "missing") // ok

delete работает и с nil map:

var m map[string]int
delete(m, "go") // ok

Удаление не гарантирует немедленного возврата памяти операционной системе. Если map была большой, а потом из неё удалили почти всё, память может остаться за внутренними структурами. Для таких случаев иногда проще создать новую map и переложить туда нужные данные.

len для map

len(m) возвращает количество пар ключ-значение:

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

fmt.Println(len(m)) // 2

Для nil map len вернёт 0.

var m map[string]int
fmt.Println(len(m)) // 0

Какие типы можно использовать как ключ map

Ключ map должен быть comparable, то есть его можно сравнить через ==.

Можно использовать:

string
int, int64, uint64 и другие числа
bool
указатели
каналы
структуры, если все их поля сравнимы
массивы, если элементы сравнимы

Нельзя использовать как ключ:

slice
map
function
struct, если внутри есть slice, map или function

Такой код не скомпилируется:

m := make(map[[]int]string) // invalid map key type []int

Slice нельзя сравнить через ==, кроме сравнения с nil, поэтому он не может быть ключом.

golang map struct: структура как ключ

Struct можно использовать как ключ, если все поля сравнимы.

Это удобно, когда ключ состоит из нескольких частей.

Плохой вариант через вложенную map:

hits := make(map[string]map[string]int)

Для записи придётся проверять внутреннюю map:

func addHit(hits map[string]map[string]int, path, country string) {
    if hits[path] == nil {
        hits[path] = make(map[string]int)
    }
    hits[path][country]++
}

Более аккуратный вариант — struct key:

type HitKey struct {
    Path    string
    Country string
}

hits := make(map[HitKey]int)

hits[HitKey{Path: "/blog", Country: "ru"}]++

Код проще, меньше проверок, меньше вложенности.

Такой подход часто используют для составных индексов: пользователь + день, путь + страна, сервис + статус, товар + склад.

map как set в Go

В Go нет отдельного встроенного типа set, но его легко сделать через map.

Вариант через bool:

seen := make(map[string]bool)

seen["go"] = true

if seen["go"] {
    fmt.Println("already seen")
}

Вариант через пустую структуру:

seen := make(map[string]struct{})

seen["go"] = struct{}{}

if _, ok := seen["go"]; ok {
    fmt.Println("already seen")
}

struct{}{} не занимает памяти под значение, поэтому для больших set часто используют именно map[T]struct{}.

map со slice в значении

Один из самых удобных паттернов — map[string][]T.

Например, сгруппируем пользователей по городу:

type User struct {
    Name string
    City string
}

users := []User{
    {Name: "Niyaz", City: "Kazan"},
    {Name: "Mark", City: "Moscow"},
    {Name: "Ilya", City: "Kazan"},
}

byCity := make(map[string][]User)

for _, user := range users {
    byCity[user.City] = append(byCity[user.City], user)
}

Здесь не нужно проверять, есть ли уже ключ user.City. Если ключа нет, byCity[user.City] вернёт nil slice, а append к nil slice работает нормально.

Это нормальный, идиоматичный Go.

golang map values: как получить все значения map

В Go нет встроенной функции values(m), как в некоторых языках. Значения собирают вручную.

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

values := make([]int, 0, len(m))
for _, v := range m {
    values = append(values, v)
}

fmt.Println(values)

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

Если нужен стабильный порядок, сначала собери и отсортируй ключи.

golang map to slice: как превратить map в slice

Чаще всего map превращают в slice для сортировки, вывода или передачи дальше.

Например, нужно получить отсортированный список ключей:

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

keys := make([]string, 0, len(m))
for k := range m {
    keys = append(keys, k)
}

sort.Strings(keys)

for _, k := range keys {
    fmt.Println(k, m[k])
}

Если нужно собрать slice структуру:

type Pair struct {
    Key   string
    Value int
}

pairs := make([]Pair, 0, len(m))
for k, v := range m {
    pairs = append(pairs, Pair{Key: k, Value: v})
}

Это нормальный способ сделать golang map to slice без магии.

Порядок range по map не гарантирован

Одна из частых ловушек: range по map не обязан возвращать ключи в том порядке, в котором ты их добавлял.

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

for k, v := range m {
    fmt.Println(k, v)
}

Порядок может отличаться между запусками и даже между разными обходами.

Нельзя писать код, который зависит от порядка map. Если порядок нужен, используй отдельный slice ключей и сортировку.

keys := make([]string, 0, len(m))
for k := range m {
    keys = append(keys, k)
}

sort.Strings(keys)

for _, k := range keys {
    fmt.Println(k, m[k])
}

Это важно и для тестов. Если тест сравнивает вывод map как строку, он может случайно падать.

Map передаётся в функцию: что реально происходит

Map часто называют reference type. На практике важно понимать точнее: значение map содержит ссылку на внутреннюю структуру runtime.

Если передать map в функцию и изменить элемент, изменение будет видно снаружи:

func update(m map[string]int) {
    m["go"] = 10
}

func main() {
    m := map[string]int{"go": 1}
    update(m)
    fmt.Println(m["go"]) // 10
}

Но если внутри функции присвоить параметру новую map, внешняя переменная не изменится:

func replace(m map[string]int) {
    m = map[string]int{"go": 100}
}

func main() {
    m := map[string]int{"go": 1}
    replace(m)
    fmt.Println(m["go"]) // 1
}

В Go всё передаётся по значению. Просто значение map внутри содержит ссылку на общую внутреннюю структуру.

Как скопировать map в Golang

Простое присваивание не копирует данные:

m1 := map[string]int{"a": 1}
m2 := m1

m2["a"] = 100
fmt.Println(m1["a"]) // 100

m1 и m2 смотрят на одну и ту же map.

Чтобы сделать копию, нужно пройтись циклом:

func cloneMap(src map[string]int) map[string]int {
    dst := make(map[string]int, len(src))
    for k, v := range src {
        dst[k] = v
    }
    return dst
}

Если значения — slice, map или указатели, это будет поверхностная копия.

Пример:

src := map[string][]int{
    "a": {1, 2, 3},
}

dst := make(map[string][]int, len(src))
for k, v := range src {
    dst[k] = v
}

dst["a"][0] = 100
fmt.Println(src["a"][0]) // 100

Чтобы полностью скопировать map[string][]int, нужно копировать ещё и slice:

dst := make(map[string][]int, len(src))
for k, v := range src {
    copied := make([]int, len(v))
    copy(copied, v)
    dst[k] = copied
}

Это как раз ответ на частый запрос golang — как скопировать map slice interface.

Если в значениях лежат interface{}, структура копирования зависит от реального типа внутри интерфейса. Универсального безопасного deep copy в Go нет без рефлексии или ручной логики под конкретные типы.

Можно ли сравнивать map

Map можно сравнивать только с nil.

var m map[string]int
fmt.Println(m == nil) // true

Так нельзя:

m1 := map[string]int{"a": 1}
m2 := map[string]int{"a": 1}

fmt.Println(m1 == m2) // compile error

Для сравнения содержимого можно использовать reflect.DeepEqual:

fmt.Println(reflect.DeepEqual(m1, m2))

Но в production-коде часто лучше написать явное сравнение. Так понятнее, быстрее и легче контролировать нюансы.

Например:

func equalMaps(a, b map[string]int) bool {
    if len(a) != len(b) {
        return false
    }

    for k, av := range a {
        bv, ok := b[k]
        if !ok || av != bv {
            return false
        }
    }

    return true
}

Почему нельзя взять адрес значения map

Такой код не скомпилируется:

m := map[string]int{"a": 1}
p := &m["a"] // invalid operation

Причина в устройстве map. Элементы внутри map могут переезжать при росте. Если бы Go разрешил взять адрес значения, этот указатель мог бы стать невалидным.

Если нужен указатель, храни указатели как значения:

type User struct {
    Name string
}

users := map[int]*User{
    1: {Name: "Niyaz"},
}

users[1].Name = "Niyaz Updated"

Либо достань значение, измени и запиши обратно:

m := map[string]User{
    "a": {Name: "old"},
}

u := m["a"]
u.Name = "new"
m["a"] = u

Map внутри struct

Частая ошибка — структура с map-полем без конструктора.

type Cache struct {
    items map[string]string
}

var c Cache
c.items["a"] = "b" // panic

Поле items равно nil, потому что zero value для map — nil.

Правильно:

func NewCache() *Cache {
    return &Cache{
        items: make(map[string]string),
    }
}

Или лениво инициализировать перед записью:

func (c *Cache) Set(k, v string) {
    if c.items == nil {
        c.items = make(map[string]string)
    }
    c.items[k] = v
}

Если структура с map должна быть готова к использованию после var c Cache, нужно предусмотреть такую инициализацию в методах.

Как map устроена под капотом до Go 1.24

Подписаться на мой Youtube

До Go 1.24 классическая реализация map строилась вокруг buckets.

Упрощённо:

map хранит заголовок hmap
внутри есть количество элементов
есть указатель на массив buckets
каждый bucket хранит до 8 пар ключ-значение
если bucket переполняется, появляются overflow buckets

При доступе по ключу Go считает hash ключа. Часть бит используется, чтобы выбрать bucket. Другая часть помогает быстро отсеивать неподходящие слоты внутри bucket.

Для ускорения используется tophash: короткий фрагмент хеша, который хранится рядом со слотами. Сначала Go сравнивает tophash, и только если он совпал, сравнивает полный ключ.

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

Схема чтения примерно такая:

посчитать hash ключа
найти bucket
пройти по слотам bucket
сравнить tophash
при совпадении сравнить ключ полностью
если не нашли, идти в overflow bucket
если нигде нет — вернуть zero value

Снаружи это выглядит как обычный m[key], но внутри происходит довольно много работы.

Как растёт map в Go

Map растёт, когда ей становится тесно.

Причины роста:

слишком высокий load factor
слишком много overflow buckets

Если элементов становится много, Go выделяет новый массив buckets. В старой реализации рост был инкрементальным: map не переносила все элементы сразу, а постепенно эвакуировала buckets во время последующих операций.

Это нужно, чтобы не получить большую паузу на переносе данных.

Практический вывод простой: если ты заранее знаешь примерный размер map, передавай hint.

m := make(map[string]int, len(items))

На больших объёмах это может заметно снизить количество перераспределений и ускорить заполнение.

Что изменилось в map в Go 1.24

В Go 1.24 реализация map внутри рантайма была серьёзно переработана и перешла к подходу на базе Swiss tables.

Для обычного разработчика важный момент такой: синтаксис и поведение map не поменялись.

По-прежнему:

range не гарантирует порядок
nil map можно читать, но нельзя писать
map не безопасна для конкурентной записи
ключ должен быть comparable
нельзя взять адрес m[key]

Изменения внутри направлены на производительность: более компактное хранение, меньше лишних переходов по памяти, быстрее lookup на больших map.

Если ты пишешь обычный код, специально ничего менять не нужно. Но если у тебя hot path, большие кеши, индексы или map на сотни тысяч элементов, после апгрейда Go есть смысл перепрогнать бенчмарки.

Ещё один момент: если ты анализируешь pprof и завязан на внутренние имена runtime-функций, после новых версий Go профили могут выглядеть иначе.

Map и конкурентность: почему concurrent map writes падает

Обычная map в Go не thread-safe.

Такой код опасен:

m := make(map[string]int)

for i := 0; i < 10; i++ {
    go func(i int) {
        m[fmt.Sprint(i)] = i
    }(i)
}

При конкурентной записи можно получить:

fatal error: concurrent map writes

Чтение одновременно с записью тоже небезопасно.

Правильный вариант — защищать map через mutex.

type SafeCounter struct {
    mu sync.RWMutex
    m  map[string]int
}

func NewSafeCounter() *SafeCounter {
    return &SafeCounter{
        m: make(map[string]int),
    }
}

func (c *SafeCounter) Inc(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()

    c.m[key]++
}

func (c *SafeCounter) Get(key string) int {
    c.mu.RLock()
    defer c.mu.RUnlock()

    return c.m[key]
}

RWMutex позволяет нескольким goroutines читать одновременно, но запись идёт эксклюзивно.

golang sync map: когда использовать sync.Map

В Go есть sync.Map, но это не замена обычной map на каждый день.

Она полезна в специфичных сценариях:

много goroutines читают данные
записи редкие
ключи живут долго
кеш постепенно наполняется и потом в основном читается
разные goroutines работают с разными ключами

Пример:

var cache sync.Map

cache.Store("go", 1)

value, ok := cache.Load("go")
if ok {
    fmt.Println(value)
}

cache.Delete("go")

Минусы sync.Map:

теряется типобезопасность, значения имеют тип any
код становится менее очевидным
не всегда быстрее обычной map с mutex
сложнее контролировать инварианты

Для большинства случаев в бизнес-логике лучше обычная map + sync.RWMutex.

sync.Map стоит брать, когда ты понимаешь профиль нагрузки и можешь объяснить, почему обычной map с mutex недостаточно.

map[string]interface{} и map[string]any

В Go часто встречается:

var data map[string]interface{}

или с Go 1.18:

var data map[string]any

any — это alias для interface{}.

Такой тип часто используют для динамического JSON:

var payload map[string]any
err := json.Unmarshal(body, &payload)

Но злоупотреблять этим не стоит. Ты теряешь типы и начинаешь проверять всё руками:

name, ok := payload["name"].(string)
if !ok {
    return errors.New("name must be string")
}

Если структура данных известна, лучше описать struct.

type CreateUserRequest struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

map[string]any удобна на границах системы, где данные правда динамические. Внутри бизнес-логики она часто превращается в источник ошибок.

golang strings map: map для строк и rune

Иногда ищут golang strings map, имея в виду обработку строк через map.

Например, посчитать символы:

s := "golang"
counts := make(map[rune]int)

for _, r := range s {
    counts[r]++
}

fmt.Println(counts)

Важно использовать rune, а не byte, если строка может содержать кириллицу или другие unicode-символы.

s := "привет"
for _, r := range s {
    fmt.Println(string(r))
}

Map хорошо подходит для задач на строки: частоты, уникальные символы, индексы, группировки, анаграммы.

Пример группировки слов по отсортированным буквам:

func sortString(s string) string {
    r := []rune(s)
    sort.Slice(r, func(i, j int) bool {
        return r[i] < r[j]
    })
    return string(r)
}

func groupAnagrams(words []string) map[string][]string {
    groups := make(map[string][]string)

    for _, word := range words {
        key := sortString(word)
        groups[key] = append(groups[key], word)
    }

    return groups
}

Map vs struct

Map и struct решают разные задачи.

Struct лучше, когда набор полей известен:

type User struct {
    ID   int
    Name string
    Age  int
}

Map лучше, когда ключи динамические:

settings := map[string]string{
    "theme": "dark",
    "lang":  "ru",
}

Не стоит использовать map вместо struct только потому, что так быстрее набросать.

Плохо:

user := map[string]any{
    "id":   1,
    "name": "Niyaz",
    "age":  30,
}

Если это доменная модель, лучше struct. Компилятор будет помогать, IDE будет подсказывать, код будет проще читать.

Map vs slice

Slice хорош, когда важен порядок и доступ по индексу.

Map хороша, когда важен быстрый доступ по ключу.

Пример: есть список пользователей, и нужно часто искать по ID.

Через slice:

func findUser(users []User, id int) (User, bool) {
    for _, user := range users {
        if user.ID == id {
            return user, true
        }
    }
    return User{}, false
}

Это O(n).

Через map:

usersByID := make(map[int]User)
for _, user := range users {
    usersByID[user.ID] = user
}

user, ok := usersByID[42]

Поиск в среднем O(1).

Но map не сохраняет порядок. Если нужен и порядок, и быстрый поиск, часто используют обе структуры: slice для порядка, map для индекса.

Golang maps cheatsheet

Короткая шпаргалка по map в Go.

Создать map:

m := make(map[string]int)

Создать с начальными значениями:

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

Создать с hint:

m := make(map[string]int, 1000)

Добавить или обновить:

m["a"] = 10

Получить:

v := m["a"]

Проверить наличие ключа:

v, ok := m["a"]

Удалить:

delete(m, "a")

Длина:

len(m)

Обход:

for k, v := range m {
    fmt.Println(k, v)
}

Собрать ключи:

keys := make([]string, 0, len(m))
for k := range m {
    keys = append(keys, k)
}

Скопировать map:

dst := make(map[string]int, len(src))
for k, v := range src {
    dst[k] = v
}

Защитить map от конкурентного доступа:

type SafeMap struct {
    mu sync.RWMutex
    m  map[string]int
}

Частые ошибки с map в Go

Запись в nil map

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

Исправление:

m := make(map[string]int)

Ожидание стабильного порядка range

for k := range m {
    fmt.Println(k)
}

Порядок не гарантирован. Нужен порядок — сортируй ключи.

Конкурентная запись без mutex

go func() { m["a"] = 1 }()
go func() { m["b"] = 2 }()

Нужен sync.Mutex, sync.RWMutex или sync.Map.

Простое присваивание вместо копии

m2 := m1

Это не копия данных. Это ещё одна ссылка на ту же map.

Использование map[string]any вместо struct

Если структура известна заранее, используй struct. Map с any оставь для динамических данных.

Попытка взять адрес элемента

&m["a"] // нельзя

Храни указатели в map или доставай значение, меняй и записывай обратно.

Что спрашивают про map на собеседовании по Go

На собеседованиях по Golang map любят не за синтаксис. Синтаксис простой. Проверяют нюансы.

Частые вопросы:

Что такое map в Go?
Как создать map через make?
Чем nil map отличается от пустой map?
Что будет при чтении из nil map?
Что будет при записи в nil map?
Как проверить, есть ли ключ?
Почему порядок range по map случайный?
Какие типы можно использовать как ключ?
Почему slice нельзя использовать как ключ?
Можно ли сравнивать map?
Почему нельзя взять адрес m[key]?
Что будет при concurrent map writes?
Когда использовать sync.Map?
Как скопировать map?
Как получить keys или values из map?
Как работает map под капотом?
Что изменилось в Go 1.24?

Если можешь ответить на эти вопросы с примерами, тема map у тебя закрыта намного лучше, чем у большинства.

Заключение

Map в Go — одна из самых полезных структур данных, но в ней много нюансов.

На уровне синтаксиса всё просто: make, m[key], delete, range. На уровне реальной разработки появляются детали: nil map, zero value, случайный порядок обхода, сравнимые ключи, копирование, конкурентный доступ, рост под капотом и поведение после удаления.

Главное, что стоит запомнить:

nil map можно читать, но нельзя писать
ключ должен быть comparable
порядок range не гарантирован
map нельзя безопасно писать из нескольких goroutines без синхронизации
простое присваивание не копирует map
для больших map полезен hint в make
sync.Map нужен не всегда
struct key часто лучше вложенных map
после Go 1.24 внутренняя реализация изменилась, но внешнее поведение осталось прежним

Если ты готовишься к собеседованию по Go, map нужно понимать не как набор команд, а как структуру с понятным поведением и ограничениями. Именно на этих ограничениях чаще всего и проверяют глубину.