Удаляем ключ из map в Go: что скрывается под капотом?

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Delete key in map: как это работает под капотом в Go

Вы когда-нибудь задумывались, что на самом деле происходит, когда вы пишете delete(myMap, "key") в Go? Просто исчезает ли ключ из памяти? Или там остаётся "дырка"? А что, если удалить ключ из nil-мапы? Если вы задавали себе эти вопросы — вы не одиноки. Тема delete key in map собрала тысячи просмотров на Stack Overflow, и сегодня мы заглянем под капот этого, казалось бы, простого действия.

В этой SEO-статье мы разберём, как устроена хеш-таблица в Go (структура hmap), как работает удаление ключа, куда девается память и почему не стоит бояться delete в циклах. Поехали!

Краткий экскурс: как устроена map в Go

Прежде чем говорить об удалении, давайте вспомним, как map golang хранит данные. Внутри — это хеш-таблица, структура hmap. Она состоит из массива "вёдер" (buckets), каждое из которых может хранить до 8 пар ключ-значение. Когда вы добавляете ключ, Go вычисляет хеш, находит ведро и помещает пару внутрь. Если ведро переполняется, создаётся цепочка переполнения (overflow bucket).

Это классическая реализация, но с парой хитростей, о которых мы поговорим ниже.

Структура hmap (упрощённо)

type hmap struct {
    count     int     // количество элементов
    flags     uint8
    B         uint8   // логарифм количества ведер
    buckets   unsafe.Pointer // указатель на массив ведер
    oldbuckets unsafe.Pointer // при росте мапы
    nevacuate uintptr
    // ...
}

Ключевое: buckets — это непрерывный массив. Удаление не сжимает этот массив, а лишь помечает ячейку как "пустую".

Delete key in map: как это работает на уровне кода

Вызов delete(m, k) в Go — это встроенная функция, которая компилируется в вызов рантайма. Внутри происходит примерно следующее:

Вычисление хеша ключа — Go использует хеш-функцию, специфичную для типа ключа.
Поиск ведра — по младшим битам хеша определяется номер ведра.
Линейный поиск внутри ведра (и цепочек переполнения) — находит ячейку с нужным ключом.
Очистка памяти — Go обнуляет память под ключ и значение, чтобы сборщик мусора мог их собрать.
Пометка ячейки как "пустой" — специальный флаг emptyRest или emptyOne.
Уменьшение счётчика — m.count--.

Всё это происходит за O(1) в среднем, но с учётом коллизий — может быть O(n) в худшем случае.

Пример кода: delete в действии

package main

import "fmt"

func main() {
    m := map[string]int{
        "apple":  5,
        "banana": 3,
        "cherry": 7,
    }

    fmt.Println("До удаления:", m)
    delete(m, "banana")
    fmt.Println("После удаления:", m)

    // Попробуем удалить несуществующий ключ
    delete(m, "grape") // ничего не произойдет, ошибки нет
    fmt.Println("После удаления несуществующего:", m)
}

Обратите внимание: delete key in map для несуществующего ключа — это безопасная операция. Она просто ничего не делает. Это одно из частых заблуждений новичков.

Что происходит с памятью? Мифы и реальность

Многие разработчики боятся, что после delete в мапе остаются "дырки", которые приводят к утечкам памяти. Давайте разберёмся.

Память под ключи и значения

Когда вы удаляете ключ, Go обнуляет память под этот элемент. Если ключ или значение были указателями или содержали указатели (строки, срезы, мапы), то сборщик мусора сможет их собрать. Сама же ячейка в ведре остаётся, но помечена как пустая.

Это значит, что мапа не уменьшается в размере после удаления. Если вы добавили 1000 элементов, а потом удалили 999, мапа всё ещё занимает память под 1000 элементов (точнее, под количество ведер, рассчитанное на 1000).

Когда это проблема?

Если вы постоянно добавляете и удаляете ключи в цикле — мапа может "раздуться". Но для большинства приложений это не критично. Если же вы работаете с очень большими мапами и часто их очищаете — возможно, стоит просто создать новую мапу вместо удаления всех ключей.

// Плохо: удаляем все ключи по одному
for k := range m {
    delete(m, k)
}

// Хорошо: просто создаём новую мапу
m = make(map[string]int)

Второй вариант позволяет сборщику мусора сразу собрать всю старую мапу.

Delete key in map vs nil map

Ещё один популярный вопрос: что будет, если вызвать delete на nil мапе?

var m map[string]int // nil map
delete(m, "key")    // ничего не произойдет, паники нет

Да, это безопасно. Delete key in map на nil мапе — это no-op. Однако попытка записи в nil мапу (m["key"] = 1) вызовет панику. Запомните это различие.

Внутренняя кухня: как Go помечает "пустые" ячейки

В исходном коде рантайма Go (файл runtime/map.go) есть интересная деталь: при удалении ключа используется функция mapdelete. Она не просто обнуляет память, но и проверяет, не является ли удаляемый элемент последним в ведре. Если да — он помечается как emptyRest, что ускоряет последующий поиск.

Это оптимизация: если вы ищете ключ и дошли до emptyRest, можно сразу остановиться — дальше в этом ведре ключей точно нет.

Флаги tophash

Каждое ведро хранит массив tophash — по одному байту на каждую из 8 ячеек. Этот байт содержит старшие 8 бит хеша (для быстрого сравнения) или специальные значения: