Что произойдет после append внутри функции?

Слайсы в Go — одна из самых частых причин недопонимания у разработчиков, особенно когда речь идет о передаче их в функции. Рассмотрим конкретный пример, который демонстрирует важное различие между поведением слайса как структуры данных и его внутренним представлением.

Постановка задачи

Дан следующий код:

mutate := func(a []int) {
    a[0] = 0
    a = append(a, 1)
    fmt.Println(a)
}

a := []int{1, 2, 3, 4}
mutate(a)
fmt.Println(a)

Вопрос: что будет выведено на экран?

Ответ

Программы выведет:

[0 2 3 4 1]
[0 2 3 4]

Детальный разбор

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

Внутреннее представление слайса

Слайс в Go — это не просто ссылка на массив, а структура данных из трех элементов:

• ptr — указатель на первый элемент массива (или на часть массива)
• len — текущая длина слайса
• cap — емкость слайса (сколько элементов можно добавить без переаллокации)

Когда создаем слайс a := []int{1, 2, 3, 4}, в памяти создается массив из 4 элементов, а переменная a содержит:

• ptr → адрес первого элемента массива
• len = 4
• cap = 4

Передача слайса в функцию

Важный момент: слайс передается по значению. Это значит, что функция mutate получает копию структуры слайса. Однако указатель внутри этой копии указывает на тот же самый массив, что и исходный слайс.

Рассмотрим выполнение построчно:

Шаг 1. Вход в функцию

Исходный слайс a: ptr → [1, 2, 3, 4], len = 4, cap = 4
Копия слайса a': ptr → [1, 2, 3, 4], len = 4, cap = 4

Шаг 2. Выполнение a[0] = 0

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

Массив: [0, 2, 3, 4]
Исходный слайс: ptr → [0, 2, 3, 4], len = 4, cap = 4
Копия слайса: ptr → [0, 2, 3, 4], len = 4, cap = 4

Шаг 3. Выполнение a = append(a, 1)

Здесь происходит ключевое событие. Текущая длина слайса (len) равна 4, емкость (cap) тоже 4. При попытке добавить пятый элемент происходит следующее:

• Выделяется новый массив большего размера (обычно cap * 2)
• Все элементы копируются в новый массив
• Добавляется новый элемент
• Возвращается новый слай с обновленными ptr, len, cap

Важно: этот новый слайс присваивается переменной a внутри функции (параметру). Исходный слайс а в функции main продолжает указывать на старый массив.

После append:

Новый массив (для копии): [0, 2, 3, 4, 1]
Копия слайса (внутри mutate): ptr → [0, 2, 3, 4, 1], len = 5, cap = 8

Старый массив (для исходного слайса): [0, 2, 3, 4]
Исходный слайс (в main): ptr → [0, 2, 3, 4], len = 4, cap = 4

Шаг 4: Вывод внутри функции

fmt.Println(a) выводит содержимое копии слайса: [0 2 3 4 1]

Шаг 5. Вывод после функции

fmt.Println(a) выводит исходный слайс, который продолжает указывать на старый массив: [0 2 3 4]

Почему изменился первый элемент?

Первый элемент изменился и в исходном слайсе, потому что на момент выполнения a[0] = 0 оба слайса указывали на один массив. Операция append создала новый массив только для копии слайса.

Как сделать так, чтобы изменения сохранялись?

Если нужно, чтобы изменения, сделанные внутри функции (включая добавление элементов), отразились на исходной переменной, есть два пути:

1. Возвращать новый слайс из функции:

mutate := func(a []int) []int {
    a[0] = 0
    a = append(a, 1)
    fmt.Println(a)
    return a
}

a := []int{1, 2, 3, 4}
a = mutate(a)
fmt.Println(a) // [0 2 3 4 1]

2. Передавать указатель на слайс:

mutate := func(a *[]int) {
    (*a)[0] = 0
    *a = append(*a, 1)
    fmt.Println(*a)
}

a := []int{1, 2, 3, 4}
mutate(&a)
fmt.Println(a) // [0 2 3 4 1]

Ключевые выводы

1. Слайсы передаются в функции по значению, но содержат указатель на массив.
2. Изменение элементов слайса через индекс влияет на исходный массив, пока не произошла переаллокация.
3. Операция append может создать новый массив, если емкость слайса недостаточна.
4. После переаллокации копия слайса в функции и исходный слайс указывают на разные массивы.
5. Для сохранения результатов модификации слайса нужно либо возвращать его из функции, либо передавать указатель.

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

Сталкивались ли вы с неожиданным поведением слайсов в своем коде? Как вы отлаживали такие ситуации? Поделитесь опытом в комментариях.