Срезы: append, copy и подводные камни

В уроке 17 мы оставили срез на пороге роста: запись за границей срез не растягивает, len и cap у свежего среза равны, а фраза «запас под будущий append» так и осталась обещанием. Время выполнить его. append — встроенная функция, которая дописывает элементы в конец среза и возвращает обновлённый срез. Синтаксис один для любых типов: s = append(s, 5), names = append(names, "ada"), nums = append(nums, 18, 21, 19) — три числа одним вызовом. Есть и вторая форма, append(s, other...), которая дописывает сразу все элементы другого среза — она пригодится при склейке и удалении.

Две детали, без которых append не понять. Первая: append не меняет срез на месте — он возвращает новый заголовок, и его обязательно присваивать обратно той же переменной: s = append(s, v). Голый вызов append(s, v) без присваивания даже скомпилируется, но результат улетит в никуда: сколько элементов было, столько и осталось. Вторая: дописывать можно в любой срез, включая nil-срез из урока 17 и пустой литерал — язык сам выделит память. Массив из урока 16 прирастать не умеет вовсе: [3]int навсегда [3]int. Вся динамика go-коллекций — срезы, и почти вся динамика — это append.

Что происходит с памятью, когда append дописывает за пределы cap? Срез устраивает переезд: выделяется новый массив побольше, старые элементы копируются туда, дописанный встаёт следом, а заголовок s начинает смотреть на новый дом. len при этом растёт на единицу, а cap — скачками: язык не добавляет по одной ячейке, а резервирует с запасом, чтобы следующие append обошлись без переезда. В настоящем Go запас растёт примерно удвоением: у пустого среза после первого append cap 1, потом 2, 4, 8 — на сотнях элементов шаг становится щедрее, но идея та же.

Из этой схемы следует важное про скорость. Каждый отдельный append чаще всего просто пишет в готовую ячейку, а переезды случаются всё реже: если сложить работу по всем дописываниям, каждый элемент в сумме переписывается ограниченное число раз. Значит, рост среза через append стоит в среднем O(1) на элемент — амортизированно, как говорят программисты. Прикладной вывод: дописывать по одному в цикле не страшно, это не квадратичная ловушка, как могло показаться.

А вот cap после каждого append в уроке мы печатать не будем — на этом месте движки песочницы расходятся: резервный интерпретатор всегда рисует cap равным len и никакого удвоения не знает. Поэтому следующий блок без кнопки: рост ёмкости один раз стоит увидеть в настоящем Go.

Вот главный подводный камень срезов, ради которого урок и назван «подводные камни». Срез — окно: указатель, len, cap. Если два среза смотрят на один массив и у окна есть запас ёмкости (len меньше cap), append НЕ устраивает переезд — он дописывает элемент прямо в общий массив, в ячейку за пределами len окна. А та ячейка может принадлежать другому срезу — и тот увидит в себе чужую правку. Такой шаринг памяти — не баг языка, а прямое следствие устройства среза из урока 17.

Сценарий классической ошибки: вырезали голову s[:2], дописали в неё элемент — и в оригинале s тихо испортился третий элемент. Никакой ошибки в консоли: программа работает, числа слегка неправильные. Такие баги живут в коде неделями, потому что падать нечему.

Разберём, когда append безопасен, а когда опасен. Безопасно, если у среза нет запаса — len == cap: append выделит новый массив и чужую память не заденет; именно поэтому присваивание t := s от свежего литерала в уроке 17 вело себя прилично. Опасно, если окно вырезано операцией среза s[i:j] из более длинного среза — за его len обычно лежат живые элементы оригинала. И тонкость песочницы: резервный движок копирует данные при срезании, поэтому в нём ошибку воспроизвести нельзя — она просто не проявится. Проверяйте пример ниже в основном движке или локальном Go.

Срез — заголовок из трёх слов, и в функцию приезжает копия заголовка, а не копия данных. Из этого следуют два разных поведения. Правка элементов внутри функции видна снаружи: nums[0] = 99 меняет общий массив — мы прогоняли это ранимым примером в уроке 17. А вот append внутри функции снаружи не заметен: функция дописала элемент и переприсвоила свой ЛОКАЛЬНЫЙ заголовок — на этом всё кончилось. Снаружи len остался старым; новый элемент живёт где-то в памяти, но через чужой заголовок не виден.

Отсюда железное правило идиомы: функция, которая растит срез, обязана вернуть его — func grow(s []int) []int — а место вызова обязано присвоить результат обратно: s = grow(s). Так устроен сам append — принимает срез, возвращает срез — и так пишется весь прикладной Go. Правило страхует дважды: вы не потеряете элементы, дописанные в функции, и не удивитесь, почему их «нет».

Пара нюансов напоследок. Передача среза в функцию дешёвая всегда: три машинных слова, данные не копируются, хоть за окном миллион элементов. А функция, которая только читает, тоже берёт []int: nil-срез и пустой срез читаются безопасно — range сделает ноль оборотов, len вернёт 0, это мы проверяли в уроке 17.

Вторая половина пары — copy: встроенная функция копирует элементы из одного среза в другой и возвращает число скопированных элементов. Вызов copy(dst, src) копирует ИЗ src В dst: приёмник первый, источник второй — легко перепутать, держите в голове «скопировать В». Правило минимальной длины: копируется min(len(dst), len(src)) элементов, лишнее молча отбрасывается. Если источник короче приёмника, dst не обрезается: скопированная часть ложится в начало, хвост остаётся как был — у свежего make это нули.

Типичные задачи пары. Независимая копия: c := make([]int, len(s)); copy(c, s) — теперь правки c не задевают s, в отличие от t := s, которое делит данные. Склейка двух срезов: t := make([]int, 0, len(a)+len(b)); t = append(t, a...); t = append(t, b...) — форма с запасом, про которую честный callout ниже.

Ручной цикл range делает то же самое: for i, v := range src { dst[i] = v } — но только пока dst не короче src, иначе запись за границей. copy короче и безопаснее на разных длинах: сам отрезает по минимуму. В цикле ещё и помни, что v — копия, и писать надо строго по индексу; copy об этом думает за вас. На маленьких срезах разницы в скорости нет — выбирайте читаемость.

У операции среза есть полная форма с третьим индексом: guard := s[low:high:max]. Первые два — знакомый полуинтервал, третий задаёт ёмкость результата: cap = max - low. Смысл — поводок. Обычная вырезка head := s[:2] от литерала из пяти элементов получает cap 5 и может дописывать в чужие ячейки — та самая классическая ошибка выше. Вырезка с максимумом head := s[:2:2] получает cap 2 — ровно по len, запаса нет, и первый же append уведёт её в новый массив, не тронув s. Это встроенный предохранитель от шаринга памяти: ставьте max = high, и append от вырезки безопасен по построению.

В настоящем Go форма работает как описано: full := s[1:3:5] даёт len 2 и cap 4 (5-1), а вот head := s[:2:2] при append-е переезжает целиком. Проверить это в песочнице целиком не выйдет: резервный интерпретатор третий индекс молча игнорирует — квирк, известный с урока 17, — и рисует cap по своим правилам, так что формула cap = max - low у него не выдерживает проверки. Поэтому раздел концептуальный, без кнопки: полный срез полезен в основном движке и локальном Go, а в ранимых примерах урока не появляется.

Отдельной операции «удалить» в Go нет — её собирают из имеющихся кирпичей. Каноническая форма с сохранением порядка: s = append(s[:i], s[i+1:]...). Читается: возьми всё до i, допиши к нему всё после i, результат присвой обратно. Порядок элементов сохраняется, len уменьшается на один, а в последнем слоте массива остаётся дубль — на печать он не влияет, но помнить про него стоит. Так удаляются и первый (i = 0), и последний (i = len(s)-1) элементы: частных случаев и отдельных форм нет.

Вариант без append — копирование с конца: copy(s[i:], s[i+1:]); s = s[:len(s)-1]. Элементы после i сдвигаются на один влево прямо на месте, срез укорачивается операцией среза. Он чуть экономнее на больших срезах и не собирает промежуточный заголовок, но читается хуже; выбирайте append-форму, пока скорость не доказана профилем.

Честная нота про песочницу: append-форма удаления печатает одинаковый результат в обоих движках — поэтому ранимый пример ниже есть. А copy-вариант на месте в резервном движке НЕ работает: при срезании он копирует данные, сдвига не происходит, и срез остаётся прежним. Проверяйте его в основном движке или локальном Go; в ранимых примерах урока — только append-форма.

Двумерные срезы из урока 17 — «рваные» полки разной длины — собирались литералом. Когда размер известен в числах, матрицу собирает make: matrix := make([][]int, rows) даёт rows строк, каждая — пока nil-срез; циклом for i := range matrix строкам выдаётся ширина: matrix[i] = make([]int, cols). Получается плотная сетка rows × cols, готовая под запись по индексам. В nil-строки можно и append-ить — матрица останется рваной, если так задумано.

Приём масштабируется на всё, что «таблица, но растущая»: журнал координат, заказы по дням, сетка температур по неделям. Строки-срезы независимы: matrix[0][1] = 5 заденет только первую строку, а append к matrix добавляет целую строку — она сама срез, со своими len и cap. Перебор — range снаружи, range внутри, как проговаривали в уроке 15 и 17: добавился только make-скелет.

И это последнее место, где срезам нужна помощь. Следующая коллекция курса — карты map из урока 19: там элементы лежат не по порядку и ищутся по ключу, а не по индексу, и «удалить» там — встроенная операция delete, а не собранная из append-ов.