Слайсы, мапы и строки

Создайте через make(map[K]V) или литералом map[K]V{...}. Запись — m[k] = v, чтение — m[k]. Простое чтение никогда не падает: отсутствующий ключ возвращает нулевое значение типа значения, поэтому «нет ключа» не отличить от «есть, но ноль». Форма comma-ok v, ok := m[k] это решает — ok равно false только когда ключа нет. Учтите: nil map читается нормально, но паникует на записи, так что сначала вызовите make.

Slice — это лёгкое представление поверх backing array: заголовок из указателя, длины и ёмкости (cap). append добавляет элементы в конец; пока есть свободная ёмкость, он пишет на месте, но как только длина превысила бы cap, он выделяет новый, больший backing array, копирует туда старые элементы и возвращает slice, указывающий на него. Поскольку возвращённый заголовок может отличаться, результат нужно переприсвоить: s = append(s, x).

Массив (array) имеет фиксированную длину, входящую в его тип; это значение, поэтому присваивание или передача копирует каждый элемент. Срез (slice) — небольшой заголовок на backing array; при передаче копируется только заголовок, и обе копии разделяют элементы.

nil-срез (var a []int) не имеет backing array, и a == nil равно true; пустой срез ([]int{}) ненулевой, с len 0. Оба поддерживают append и range. Для «нет результатов» предпочитают nil — но nil-срез маршалится в JSON как null, а пустой — как [].

Заголовок среза — это три машинных слова: указатель на первый элемент backing array, длина len (число доступных элементов) и ёмкость cap (число элементов от указателя до конца backing array). Сами элементы заголовок не содержит.

s[i] возвращает один byte (то есть uint8) — i-й сырой UTF-8 байт, а не символ. len(s) тоже считает байты, а не руны. ASCII-символ занимает один байт, но любой многобайтовый UTF-8 символ (скажем, é или ы) растягивается на несколько байт, поэтому len завышает счёт для такого текста, а s[i] может попасть в середину символа. Чтобы работать с символами, проходите строку через range (он декодирует руны) или конвертируйте через []rune(s) и индексируйте его.

Чтение m["x"] допустимо и возвращает нулевое значение 0 — чтение nil-map никогда не паникует. Запись m["x"] = 1 паникует с assignment to entry in nil map. Перед записью map нужно инициализировать через make(map[string]int) или литерал.

Выведет 4 4, затем x: [a b z d] и y: [a b z]. У y := x[:2] len 2, но он наследует cap 4 до конца backing array x, поэтому у append(y, "z") есть запас, и он пишет в общий x[2], перезаписывая c вместо аллокации.

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

Выведет x: [a b c d], y: [a b], z: [b c d], d: [b c], e: [a b c d]. Форма x[low:high] берёт элементы с индекса low по high-1, поэтому её длина равна high-low; опущенная граница по умолчанию равна 0 или len(x).

Код не компилируется. Строка в Go — неизменяемая последовательность байтов только для чтения, поэтому s[0] = ... недопустимо. (s[0] читает byte, а не строку, так что "R" ещё и не тот тип.) Чтобы поменять байт, конвертируйте: b := []byte(s); b[0] = 'R'; s = string(b).

Значение string — это заголовок из двух слов: 8-байтный указатель на неизменяемые UTF-8 байты плюс 8-байтная длина, поэтому на 64-битной платформе оно занимает 16 байт независимо от длины текста. Байты лежат отдельно, поэтому структура с одним полем string тоже занимает 16 байт.

И nil slice, и nil map читаются безопасно — len равен 0, обход через range ничего не даёт, а чтение nil map возвращает нулевое значение типа значения. Расхождение — на записи. К nil slice можно свободно применять append: он выделяет свежий backing array, поэтому var s []int; s = append(s, 1) просто работает и не требует инициализации. А вот nil map паникует в тот же миг, как вы присваиваете m[k] = v; перед любой записью нужно вызвать make(map[K]V) (или использовать литерал).

Все три выводят исходные значения — [1 2 3 4 5], [2 3 4 5], [3 4]. У slice1 cap равен 4, у slice2 — 3, поэтому добавление двух элементов переполняет обе ёмкости. Каждый append выделяет новый backing array и переприсваивает лишь локальную копию заголовка, поэтому заголовки вызывающей стороны и arr этого не видят.

Выбирайте массив, когда длина — фиксированная константа времени компиляции и нужна семантика значения: массивы сравнимы через ==, годятся в ключи map и копируются целиком, избегая отдельного выделения под буфер. Выбирайте слайс (по умолчанию), когда длина меняется или растёт, либо когда нужно передать представление, не копируя каждый элемент.

Buffer overflow — это запись за пределы массива или буфера, портящая соседнюю память; возможна в C, где нет проверок границ. В обычном Go её не бывает: обращения к slice и массиву проверяются по границам, и индекс вне диапазона вызывает panic, а не затирает память. Обойти это можно только пакетом unsafe.

Map в Go — это структура hmap, указывающая на массив бакетов. Каждый бакет хранит до 8 слотов ключ/значение плюс ссылку на overflow-бакеты. Хеш ключа выбирает бакет; старшие биты хеша ускоряют сканирование слотов. Когда бакеты заполняются, map растёт и перехеширует данные в больший массив.

Выведет [1 99 3] [1 99]. У a[:1] len 1, но cap 3, поэтому у append есть запас, и он пишет 99 в тот же backing array по индексу 1, перезаписывая a[1]. Принудить копию можно полным выражением среза a[:1:1], чтобы append реаллоцировал.

Сделайте независимую копию через copy(dst, src) в свежевыделенный срез или ограничьте ёмкость трёхиндексным выражением s[low:high:max], чтобы следующий append был вынужден реаллоцировать, а не перезаписывать общие элементы. Возвращайте из API копии, а не под-срезы, чтобы вызывающий не менял ваш backing array.

Когда append требует больше места, чем cap, runtime выделяет новый, больший backing array, копирует туда существующие элементы и возвращает новый заголовок на него. Ёмкость примерно удваивается для небольших срезов и растёт с меньшим коэффициентом (около 1.25x) для больших.

Срезы делят backing array, отсюда три ловушки. Запись через один срез меняет другие там, где их диапазоны пересекаются. append может затронуть, а может не затронуть оригинал — в зависимости от запаса ёмкости. А маленький под-срез держит весь большой массив живым, мешая GC. Смягчают это copy или s[low:high:max].

Печатает a b c d. range вычисляет операнд один раз в начале и итерируется по копии заголовка slice (указатель, len, cap). Переприсваивание lst совершенно новому slice лишь переназначает переменную — цикл продолжает идти по исходному backing-массиву. Если же изменить элемент исходного backing-массива, например lst[3] = "z", цикл это увидит и напечатает a b c z.

Выведет x: [x y z d], y: [x y], z: [y z d]. И y := x[:2], и z := x[1:] — это reslice x, поэтому они делят его backing array. x[1]="y", y[0] пишет в x[0]="x", а z[1] пишет в x[2]="z" — всё видно через любой перекрывающийся диапазон.

Поиск хеширует ключ, выбирает бакет, затем сравнивает старший байт хеша (tophash) с каждым из 8 слотов бакета — это 1-байтовый фильтр, пропускающий полное сравнение ключа при несовпадении. Полное сравнение ключа запускает только совпадение tophash. Если все 8 слотов не подошли, поиск идёт по указателю на overflow-бакет и повторяется по цепочке.

Элемент map не адресуем, потому что рост перемещает записи: превысив коэффициент загрузки, map выделяет больший массив бакетов и эвакуирует записи инкрементально — каждый бакет перехешируется и копируется при последующих записях. Сохранённый &m[k] повис бы после перемещения, поэтому он не компилируется.