Какая разница между zero value map и zero value слайса?

Различие между Zero Value Map и Zero Value Slice в Go

В Go концепция zero value (нулевого значения) критически важна для понимания поведения типов при их объявлении без явной инициализации. Разница между zero value для map и slice принципиальна из-за их внутреннего устройства и семантики использования.

Что такое Zero Value?

Zero value — это значение, которое переменная получает при объявлении через var без ициализации. Для каждого типа в Go определено своё нулевое значение:

• Числовые типы: 0
• Строки: "" (пустая строка)
• Булевы типы: false
• Ссылочные типы: nil

Zero Value для Map

var m map[string]int  // m == nil

Ключевые характеристики zero value map:

• Имеет значение nil
• Не указывает на инициализированную хеш-таблицу в памяти
• Нельзя напрямую добавлять элементы
• Можно читать из неё (вернёт zero value для типа элемента)
• Можно выполнять операции проверки существования ключа
• Можно итерировать (итерация не выполнит ни одной итерации)

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

// Чтение работает - вернёт 0
value := nilMap["key"] // value == 0, ok == false

// Добавление элементов вызовет panic
// nilMap["key"] = 42 // panic: assignment to entry in nil map

// Инициализация обязательна для записи
nilMap = make(map[string]int)
nilMap["key"] = 42 // Теперь работает

Zero Value для Slice

var s []int  // s == nil

Ключевые характеристики zero value slice:

• Имеет значение nil
• Имеет длину (len) 0 и ёмкость (cap) 0
• Можно читать элементы (но будет panic при обращении по индексу, так как длина 0)
• Можно использовать с append, что создаст новый слайс
• Можно выполнять срезы
• Можно итерировать (итерация не выполнит ни одной итерации)

var nilSlice []int
fmt.Println(nilSlice == nil) // true
fmt.Println(len(nilSlice))   // 0
fmt.Println(cap(nilSlice))   // 0

// Чтение по индексу вызовет panic
// value := nilSlice[0] // panic: index out of range

// Но append работает!
nilSlice = append(nilSlice, 1, 2, 3) // Создаёт новый слайс [1, 2, 3]

// Итерирование безопасно
for i, v := range nilSlice {
    // Этот блок не выполнится для nil слайса
}

Сравнительная таблица

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

1. Для map всегда используйте make() или литерал перед записью:

// Правильно:
m := make(map[string]int)
// или
m := map[string]int{}

// Опасно:
var m map[string]int
if m == nil {
    m = make(map[string]int)
}

1. Для slice append работает с nil слайсом, но будьте осторожны с индексацией:

// append безопасен:
var s []int
s = append(s, 42) // Работает

// Индексация опасна:
var s []int
// s[0] = 42 // PANIC!

1. Проверка на nil имеет разный смысл:

func processSlice(s []int) {
    if s == nil {
        // Слайс явно не инициализирован
    }
}

func processMap(m map[string]int) {
    if m == nil {
        // Карта явно не инициализирована
    }
}

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

Философское различие

Семантическое различие отражает разную природу типов:

• Map — это ссылка на сложную структуру данных (хеш-таблицу), которая должна быть явно создана
• Slice — это дескриптор, состоящий из указателя на массив, длины и ёмкости, где append может сам позаботиться о создании базового массива

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