Что происходит с хеш-таблицей при передаче в функцию?

Поведение хеш-таблицы (map) в Go при передаче в функцию

При передаче хеш-таблицы (map) в функцию в Go происходит передача по значению, но само значение содержит указатель на структуру данных хеш-таблицы. Это создает интересный гибридный эффект: формально map передается копированием, но поскольку копируется лишь указатель на данные, все изменения содержимого map внутри функции будут видны вызывающему коду.

Механизм работы

package main

import "fmt"

func modifyMap(m map[string]int) {
    // Изменения будут видны снаружи
    m["new_key"] = 100
    
    // Перезапись существующего значения - тоже
    m["existing_key"] = 999
}

func main() {
    originalMap := map[string]int{
        "existing_key": 1,
        "another_key":  2,
    }
    
    fmt.Println("До вызова:", originalMap)
    modifyMap(originalMap)
    fmt.Println("После вызова:", originalMap)
}

Вывод:

До вызова: map[another_key:2 existing_key:1]
После вызова: map[another_key:2 existing_key:999 new_key:100]

Ключевые аспекты поведения

1. Структурные изменения видны снаружи

• Добавление новых пар ключ-значение
• Удаление элементов через delete()
• Модификация существующих значений

func structuralChanges(m map[int]string) {
    m[1] = "modified"      // Изменение
    m[3] = "new"           // Добавление
    delete(m, 2)           // Удаление
}

2. Переназначение переменной map внутри функции

Если переприсвоить переменную map внутри функции, это не повлияет на оригинальную map:

func reassignMap(m map[string]int) {
    // Создаем совершенно новую map
    m = map[string]int{"completely": 999}
    // Эти изменения НЕ будут видны снаружи
}

func main() {
    myMap := map[string]int{"original": 1}
    reassignMap(myMap)
    fmt.Println(myMap) // Выведет: map[original:1]
}

3. Сравнение с другими типами данных

Внутреннее устройство map

Под капотом map в Go — это указатель на структуру runtime.hmap:

// Упрощенное представление
type hmap struct {
    count     int    // количество элементов
    flags     uint8
    B         uint8   // log_2 от количества bucket'ов
    hash0     uint32  // seed для хеш-функции
    buckets   unsafe.Pointer // массив bucket'ов
    // ... другие поля
}

При передаче map в функцию копируется именно эта структура-указатель, а не все данные хеш-таблицы.

Практические рекомендации

Когда использовать прямое изменение:

• Когда функция должна модифицировать существующую map
• Для повышения производительности (избегаем копирования)

func updateCache(cache map[string]time.Time, key string) {
    cache[key] = time.Now() // Эффективно, не требует возврата
}

Когда возвращать новую map:

• Когда нужна иммутабельность
• При конкурентном доступе (требуется синхронизация)

func safeCopyMap(original map[int]string) map[int]string {
    copy := make(map[int]string, len(original))
    for k, v := range original {
        copy[k] = v
    }
    // Модифицируем копию
    copy[42] = "answer"
    return copy
}

Для конкурентного доступа:

func concurrentSafe(mu *sync.RWMutex, data map[string]int, key string) int {
    mu.RLock()
    defer mu.RUnlock()
    return data[key]
}

Важные нюансы

1. Nil map: Передача nil-map в функцию безопасна, но операции записи вызовут panic
2. Производительность: Передача map всегда O(1) независимо от размера
3. Сравнение с slice: Map всегда содержит указатель, slice — только иногда (когда не реаллоцируется)

Заключение

Передача map в функцию в Go — это передача легковесной ссылки на данные. Это делает операции с map эффективными, но требует осторожности: изменения видны всем держателям ссылки. Для изоляции изменений необходимо явное копирование, а для конкурентного доступа — синхронизация через мьютексы или использование sync.Map в высококонкурентных сценариях. Понимание этого механизма критически важно для написания корректного и эффективного Go-кода.