🍰 Массивы и слайсы изнутри
Слайс в Go выглядит как динамический массив, а работает как окно в чужой массив. Пока это не понятно, код с append ведёт себя непредсказуемо: запись в одну переменную меняет другую, а добавленный внутри функции элемент снаружи пропадает. Поэтому на собеседовании по языку слайсы спрашивают чаще всего остального: как устроен слайс в памяти, как он растёт и что выведет код из пяти строк
🧠 Как это устроено
Массив
Массив в Go — значение фиксированной длины, и длина входит в тип. [3]int и [4]int — разные типы, присвоить один другому нельзя. Значение массива — это сами элементы подряд, без отдельного заголовка, и при присваивании или передаче в функцию оно копируется полностью. Массивы одного типа можно сравнивать через ==
В прикладном коде массивы встречаются редко: ключ мапы фиксированной длины ([16]byte для UUID, [32]byte для хеша), буфер на стеке, таблица констант. Почти всё остальное — слайсы
Заголовок слайса
Слайс — маленькая структура из трёх полей. В рантайме она так и описана:
type slice struct {
array unsafe.Pointer // указатель на первый элемент окна
len int // сколько элементов видно
cap int // сколько поместится до конца массива
}На 64-битной машине это 24 байта, и при передаче копируются только они. Сами элементы живут в базовом массиве, на который указывает array. Разные слайсы могут смотреть в один и тот же массив, и спецификация говорит об этом прямо: слайс делит память со своим массивом и с другими слайсами того же массива
Выражение a[low:high] создаёт новый заголовок поверх того же массива: длина high - low, ёмкость до конца массива. Копирования элементов нет. Отсюда b := a[1:3] при len(a) == 5 даёт слайс длиной 2 и ёмкостью 4
Полное выражение a[low:high:max] ещё и ограничивает ёмкость: она становится max - low. Это способ сказать «дальше этого места не пиши», и он понадобится в ловушках ниже
Что делает append
append(s, x) смотрит на ёмкость:
- Если
len(s) < cap(s), элемент пишется в базовый массив сразу за длиной. Возвращается новый заголовок с той же ёмкостью и длиной на единицу больше. Массив прежний - Если места нет, рантайм выделяет новый массив, копирует туда старые элементы, дописывает новые и возвращает заголовок на новый массив. Старый массив остаётся тем, кто на него ещё смотрит
Поэтому результат append всегда присваивают: s = append(s, x). Старый заголовок о новой длине ничего не знает, а после переезда смотрит в старый массив
Как растёт ёмкость
Формула роста живёт в runtime/slice.go, функция nextslicecap, и с Go 1.18 она такая:
- если нужно больше удвоенной ёмкости (добавляют много элементов сразу), новая ёмкость равна нужной длине
- если старая ёмкость меньше 256, ёмкость удваивается
- дальше шаг плавно уменьшается: к ёмкости прибавляется
(cap + 3*256) / 4, пока её не хватит. Для больших слайсов это стремится к росту в 1,25 раза
После этого размер округляется вверх до ближайшего класса размера аллокатора. Поэтому реальные числа не совпадают с формулой в точности. Вот ёмкости []int при добавлении по одному элементу, это вывод программы:
1 2 4 8 16 32 64 128 256 512 848 1280 1792 2560После 512 формула даёт 832, это 6656 байт. Ближайший класс размера — 6784 байта, отсюда 848 элементов. Наизусть цифры знать не нужно, а вот механизм «удвоение до 256, потом мягче, потом округление под аллокатор» спрашивают регулярно. Старый ответ «до 1024 удваивается, потом на 25%» описывает Go до 1.18
🛠️ На практике
Главная ловушка — слайс от слайса пишет в общий массив. Пример ниже стоит прогнать в голове до того, как смотреть вывод
Go · Общий базовый массив и три выражения среза
func main() {
a := []int{1, 2, 3, 4, 5}
b := a[1:3] // [2 3], len 2, cap 4
fmt.Println(len(b), cap(b))
b = append(b, 99) // места хватает: пишем прямо в a[3]
fmt.Println(a, b)
c := a[1:3:3] // cap ограничен: 3 - 1 = 2
c = append(c, 100) // места нет, новый массив
c[0] = -1
fmt.Println(a, c)
s := make([]int, 3, 4)
x := append(s, 1)
y := append(s, 2) // тот же базовый массив, что у x
fmt.Println(x, y)
}Вывод:
2 4
[1 2 3 99 5] [2 3 99]
[1 2 3 99 5] [-1 3 100]
[0 0 0 2] [0 0 0 2]Во второй строке append к b затёр четвёртый элемент a: у b была свободная ёмкость, и она указывала в чужие данные. В третьей строке c с ограниченной ёмкостью переехал в новый массив, и c[0] = -1 уже не задел a. Последняя строка — классическая задача: x и y получены из одного s, оба записали элемент в одну и ту же ячейку, и победил последний
Второй пример про функции. Он отвечает на вопрос «почему мой append внутри функции не сработал»
Go · Слайс в функции и range с append
func add(s []int) {
s[0] = 100 // видно снаружи: массив общий
s = append(s, 4) // новая длина живёт только в копии заголовка
fmt.Println("внутри:", s)
}
func addPtr(s *[]int) {
*s = append(*s, 4)
}
func main() {
s := make([]int, 3, 10)
add(s)
fmt.Println("снаружи:", s, len(s))
fmt.Println("хвост:", s[:4]) // элемент 4 записан, но длина его не видит
addPtr(&s)
fmt.Println("через указатель:", s)
nums := []int{1, 2, 3}
for _, v := range nums {
nums = append(nums, v) // range взял длину один раз, цикл конечен
}
fmt.Println(nums)
}Вывод:
внутри: [100 0 0 4]
снаружи: [100 0 0] 3
хвост: [100 0 0 4]
через указатель: [100 0 0 4]
[1 2 3 1 2 3]Функция получила копию заголовка. Запись по индексу дошла до общего массива, а новая длина осталась в копии. Четвёрка при этом физически лежит в массиве, и s[:4] её показывает, потому что ёмкость позволяет. Идиоматичный выход — вернуть слайс из функции, как это делает сам append. Указатель на слайс тоже работает, но читается хуже
range вычисляет выражение один раз, до первой итерации. Поэтому цикл, который дописывает в тот же слайс, проходит только по трём исходным элементам и не зацикливается
Копирование и пакет slices
copy(dst, src) копирует min(len(dst), len(src)) элементов и возвращает это число. Частая ошибка — dst := make([]int, 0, len(src)) перед copy: длина ноль, скопируется ноль элементов. Нужна длина, а не ёмкость: make([]int, len(src))
С Go 1.21 в стандартной библиотеке есть пакет slices, и ручные приёмы из старых статей заменяются одной функцией:
| Задача | Чем делать |
|---|---|
| Независимая копия | slices.Clone(s), копия поверхностная |
| Заранее выделить место под n элементов | slices.Grow(s, n) |
| Отрезать свободную ёмкость | slices.Clip(s), то же, что s[:len(s):len(s)] |
Удалить элементы s[i:j] | slices.Delete(s, i, j), с Go 1.22 зануляет освободившийся хвост |
| Сравнить два слайса | slices.Equal(a, b), nil и пустой считаются равными |
| Отсортировать | slices.Sort, slices.SortFunc |
Сравнить два слайса через == нельзя: слайс сравнивается только с nil. Массивы сравниваются
⚠️ Где ошибаются
Возвращают подслайс большого буфера. Функция читает файл на 10 МБ в []byte и возвращает buf[:10]. Длина 10, ёмкость 10 485 760, и весь буфер живёт, пока жив этот маленький слайс. Сборщик мусора не освобождает массив по частям. Если кусок нужен надолго, копируй: slices.Clone(buf[:10]) или append([]byte(nil), buf[:10]...). У такой копии ёмкость 16 байт, а не 10 мегабайт
Отдают наружу слайс со свободной ёмкостью. Метод возвращает s.items[:n], вызывающий делает append и тихо переписывает внутреннее состояние структуры. Если владелец данных ты, отдавай s.items[:n:n] или копию
Не задают ёмкость, когда размер известен. Цикл на миллион append без make([]T, 0, n) переедет на новый массив 38 раз, и каждый переезд копирует всё накопленное. С ёмкостью аллокация одна. Разница видна в профиле сразу
Путают nil-слайс и пустой. var s []string равен nil, []string{} нет, а len у обоих ноль. Для append и range разницы нет, а для encoding/json есть: nil превращается в null, пустой в []. Фронтенд, который ждёт массив, ломается на null. Если контракт API обещает массив, инициализируй пустым
Держат указатели в удалённом хвосте. До Go 1.22 удаление через append(s[:i], s[i+1:]...) оставляло в конце массива копию последнего элемента. Для []*Order это ссылка, которая не даёт собрать объект. slices.Delete теперь зануляет хвост сам, в ручном коде это делай через clear(s[len(s)-k:])
🎯 Вопросы с собеседований
Чем массив отличается от слайса?
Массив — значение фиксированной длины, длина входит в тип, и при присваивании он копируется целиком. Слайс — заголовок из указателя на базовый массив, длины и ёмкости, 24 байта на 64-битной машине. Копируется только заголовок, элементы остаются общими. Массивы можно сравнивать через ==, слайсы сравниваются только с nil
Что такое len и cap и чем они отличаются?
len — сколько элементов видно через слайс, к ним можно обращаться по индексу. cap — сколько элементов помещается от начала слайса до конца базового массива. Пока len < cap, append пишет в тот же массив без аллокации. s[:cap(s)] разрешён и покажет элементы за длиной, а s[len(s)] вызовет панику
Как растёт слайс при append?
Если ёмкости не хватает, рантайм выделяет новый массив и копирует туда элементы. Пока ёмкость меньше 256, она удваивается, дальше шаг плавно снижается к 1,25 раза. Если за раз добавляют больше, чем помещается в удвоенный слайс, ёмкость берётся ровно под нужную длину. Потом размер округляется вверх до класса размера аллокатора, поэтому у []int после 512 идёт 848, а не 832
Почему append внутри функции не виден снаружи?
Слайс передаётся по значению, функция получает копию заголовка. append меняет длину в копии, а если ёмкости не хватило, ещё и переводит копию на новый массив. Запись по индексу видна снаружи, пока массив общий. Правильно вернуть слайс из функции, как делает сам append, либо передать указатель на слайс
Что выведет код: s := make([]int, 3, 4); x := append(s, 1); y := append(s, 2)?
И x, и y будут [0 0 0 2]. У s свободна одна ячейка, оба append пишут в неё, потому что смотрят в один базовый массив. Второй вызов перезаписал единицу двойкой. Если бы у s ёмкость была 3, каждый append выделил бы свой массив, и вышло бы [0 0 0 1] и [0 0 0 2]
Зачем нужно полное выражение среза a[low:high:max]?
Оно ограничивает ёмкость результата значением max - low. Тогда первый же append к такому слайсу выделит новый массив и не затрёт чужие данные за его длиной. Так защищают внутренний буфер, когда отдают его кусок наружу. slices.Clip(s) делает то же самое для всего слайса
Чем nil-слайс отличается от пустого?
У nil-слайса указатель nil, у пустого он указывает на массив нулевой длины. len, range и append работают с обоими одинаково, s == nil различает. Заметная разница в сериализации: encoding/json превращает nil в null, а пустой слайс в []. Для возврата из функции обычно подходит nil, для ответа API с обещанным массивом — пустой
Как сделать независимую копию слайса?
slices.Clone(s) с Go 1.21 или copy в слайс нужной длины: dst := make([]T, len(s)); copy(dst, s). Копия поверхностная: если элементы — указатели или слайсы, их содержимое останется общим. Частая ошибка — создать dst через make([]T, 0, len(s)): copy скопирует ноль элементов, потому что смотрит на длину
📚 Что почитать
- Go Slices: usage and internals — статья из блога Go с картинками заголовка и базового массива
- Arrays, slices (and strings): The mechanics of append — Роб Пайк собирает
appendруками и показывает, почему результат надо присваивать - Спецификация Go: Appending to and copying slices — точные правила
append,copyи полного выражения среза - Пакет slices — документация функций, которые заменяют ручные приёмы