Исполняемые доки Go: Слайсы

Q: Чем длина слайса отличается от ёмкости в Go?

len(s) это сколько элементов слайс содержит сейчас. cap(s) это сколько элементов помещается в базовом массиве, начиная с первого элемента слайса. append пишет в свободную ёмкость, если она есть, и выделяет новый массив большего размера, если её нет.

Q: Как добавить элемент в слайс в Go?

Вызовите встроенную append и присвойте результат обратно: s = append(s, x). Можно добавить несколько значений (append(s, 1, 2, 3)) или другой слайс (append(s, other...)). Всегда используйте возвращаемое значение, потому что append может вернуть слайс, указывающий на новый массив.

Q: Как удалить элемент из слайса в Go?

Используйте slices.Delete(s, i, i+1) (Go 1.21): она сдвигает последующие элементы и возвращает укороченный слайс. Начиная с Go 1.22 она ещё и обнуляет освободившиеся ячейки в хвосте. Если порядок не важен, поменяйте элемент местами с последним и обрежьте: s[i] = s[len(s)-1]; s = s[:len(s)-1].

Q: Как проверить, содержит ли слайс значение, в Go?

Используйте slices.Contains(s, v) из стандартного пакета slices (Go 1.21). slices.Index(s, v) возвращает позицию или -1, а slices.ContainsFunc принимает предикат. Для многократных поисков по большим данным постройте мапу.

Q: Чем nil-слайс отличается от пустого слайса в Go?

var s []int это nil; s := []int{} пустой, но не nil. У обоих длина 0, оба работают с len, range и append. Разница проявляется в проверках s == nil и в encoding/json, который кодирует nil-слайс как null, а пустой как [].

Слайс в одном примере

Слайс это растущее окно в массив. Его создают литералом или через make, увеличивают через append, а размер узнают через len.

package main

import "fmt"

func main() {
	langs := []string{"Go", "Rust"}
	langs = append(langs, "Zig", "C")
	fmt.Println(langs, len(langs))

	for i, l := range langs {
		fmt.Println(i, l)
	}

	fmt.Println(langs[1:3]) // elements 1 and 2
}

У []string нет длины в скобках. Этим он и отличается от типа массива вроде [4]string, размер которого фиксирован.

Что такое слайс

Значение слайса это небольшой заголовок из трёх полей:

указатель на элемент базового массива
длина: сколько элементов видит слайс
ёмкость: сколько элементов есть от этого указателя до конца базового массива

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

make: длина и ёмкость

make([]T, len, cap) выделяет базовый массив и возвращает слайс поверх него. Ёмкость необязательна и по умолчанию равна длине.

package main

import "fmt"

func main() {
	a := make([]int, 3) // len 3, cap 3, all zeros
	fmt.Println(a, len(a), cap(a))

	b := make([]int, 0, 10) // len 0, room for 10
	fmt.Println(b, len(b), cap(b))

	for i := range 5 {
		b = append(b, i*i)
	}
	fmt.Println(b, len(b), cap(b)) // no reallocation happened
}

Частая путаница: make([]int, 5) и затем пять вызовов append дают десять элементов, первые пять из которых нули. Используйте make([]int, 0, 5), если собираетесь добавлять через append, или make([]int, 5), если собираетесь присваивать по индексу.

Предварительное выделение ёмкости, когда итоговый размер известен, избавляет от повторных ростов. Это оптимизация, а не требование.

append и рост

append добавляет элементы после текущей длины. Если ёмкости хватает, запись идёт на месте. Если нет, выделяется массив большего размера, старые элементы копируются в него, и возвращается слайс, указывающий на новый массив.

package main

import "fmt"

func main() {
	var s []int
	prevCap := cap(s)
	for i := range 2000 {
		s = append(s, i)
		if cap(s) != prevCap {
			fmt.Printf("len %4d  cap %4d\n", len(s), cap(s))
			prevCap = cap(s)
		}
	}
}

Пока слайс маленький, ёмкость примерно удваивается, а после 256 элементов растёт с меньшим коэффициентом (приближаясь к 1.25x). Точные числа это деталь реализации среды выполнения, и они менялись между версиями Go, так что никогда не пишите код, который от них зависит.

Поскольку append может вернуть другой массив, её результат нужно использовать:

append(s, 4)     // compile error: append(s, 4) (value of type []int) is not used
s = append(s, 4) // correct

Добавление целого слайса использует синтаксис распаковки: s = append(s, other...).

Срез разделяет базовый массив

s[low:high] создаёт новый заголовок слайса над тем же массивом, охватывающий индексы от low до high, не включая high. Любую границу можно опустить. Элементы не копируются.

package main

import "fmt"

func main() {
	nums := []int{10, 20, 30, 40, 50}
	mid := nums[1:4] // 20 30 40
	mid[0] = 99
	fmt.Println(nums) // the write shows up in nums

	fmt.Println(len(mid), cap(mid)) // cap runs to the end of nums
}

Вывод:

[10 99 30 40 50]
3 4

Именно это разделение делает срезы дешёвыми. И оно же источник самого знаменитого бага со слайсами.

Баг с общим массивом при append

Когда у подслайса есть свободная ёмкость, append в него пишет в массив родителя, поверх элементов, которые родитель ещё использует.

package main

import "fmt"

func main() {
	base := []int{1, 2, 3, 4, 5}
	first := base[:2] // [1 2], cap 5

	first = append(first, 100) // fits in capacity: overwrites base[2]
	fmt.Println(base)
	fmt.Println(first)

	// Two slices built from the same prefix clobber each other.
	prefix := make([]string, 0, 4)
	prefix = append(prefix, "cmd")
	a := append(prefix, "build")
	b := append(prefix, "test")
	fmt.Println(a, b) // both print test
}

Вывод:

[1 2 100 4 5]
[1 2 100]
[cmd test] [cmd test]

a и b делят ячейку массива после "cmd", поэтому второй append перезаписал первый. Код выглядит нормально и работает, когда ёмкость случайно заполнена, поэтому баг проявляется лишь иногда.

Два способа исправить:

Полное выражение среза s[low:high:max] ограничивает ёмкость значением max-low. Без свободной ёмкости следующий append обязан выделить память. first := base[:2:2] делает первый пример безопасным.
Явное копирование, когда слайс переживёт вызов или в него будут добавлять независимо: slices.Clone(prefix) или append([]string(nil), prefix...).

Связанная ловушка: маленький слайс огромного массива удерживает весь массив от сборщика мусора. Если прочитать файл на 100 МБ и сохранить data[:10], все 100 МБ останутся в памяти. Клонируйте ту часть, которую сохраняете.

copy

Встроенная copy(dst, src) копирует min(len(dst), len(src)) элементов и возвращает это число. dst она никогда не увеличивает.

package main

import (
	"fmt"
	"slices"
)

func main() {
	src := []int{1, 2, 3}

	dst := make([]int, len(src))
	n := copy(dst, src)
	dst[0] = 100
	fmt.Println(n, src, dst) // independent

	var empty []int
	fmt.Println(copy(empty, src)) // 0: dst has no length

	c := slices.Clone(src) // the one-line version (Go 1.21)
	fmt.Println(c)
}

copy корректно обрабатывает перекрывающиеся источник и приёмник, поэтому copy(s[1:], s) сдвигает элементы вправо без порчи данных.

Пакет slices

Начиная с Go 1.21 в стандартном пакете slices есть обобщённые функции для операций, которые раньше писали вручную.

package main

import (
	"fmt"
	"slices"
)

func main() {
	s := []int{5, 2, 8, 2, 9}

	fmt.Println(slices.Contains(s, 8)) // true
	fmt.Println(slices.Index(s, 2))    // 1
	fmt.Println(slices.Max(s), slices.Min(s))

	slices.Sort(s)
	fmt.Println(s)
	i, found := slices.BinarySearch(s, 8)
	fmt.Println(i, found)

	s = slices.Compact(s) // drop adjacent duplicates
	fmt.Println(s)

	s = slices.Delete(s, 1, 2) // remove index 1
	fmt.Println(s)

	s = slices.Insert(s, 1, 3, 4)
	fmt.Println(s)

	slices.Reverse(s)
	fmt.Println(s, slices.Equal(s, []int{9, 8, 4, 3, 2}))
}

Функция	Что делает
`Contains`, `Index`	ищут значение (`ContainsFunc`, `IndexFunc` принимают предикат)
`Sort`, `SortFunc`, `SortStableFunc`	сортируют на месте
`BinarySearch`	ищет в отсортированном слайсе
`Insert`, `Delete`, `DeleteFunc`	вставляют или удаляют, возвращают новый слайс
`Compact`	удаляет идущие подряд дубликаты
`Equal`, `Compare`	сравнивают поэлементно
`Clone`, `Reverse`, `Max`, `Min`	делают то, что написано
`Collect`, `Sorted`, `Values`, `All`	работают с итераторами (Go 1.23)

Delete и Insert возвращают слайс, который нужно присвоить, как и append. Сортировке посвящена отдельная страница: сортировка.

Удаление элементов в цикле по индексу пропускает элементы. Вместо этого используйте slices.DeleteFunc:

s = slices.DeleteFunc(s, func(n int) bool { return n%2 == 0 }) // drop evens

Двумерные слайсы

Слайс слайсов даёт сетку, строки которой могут быть разной длины. Каждую строку нужно выделять отдельно.

package main

import "fmt"

func main() {
	rows, cols := 3, 4
	grid := make([][]int, rows)
	for r := range grid {
		grid[r] = make([]int, cols)
	}
	grid[1][2] = 7

	for _, row := range grid {
		fmt.Println(row)
	}

	// Rows of different lengths are fine.
	triangle := [][]int{{1}, {1, 1}, {1, 2, 1}}
	fmt.Println(triangle)
}

Если забыть внутренний make, каждая строка останется nil, и grid[1][2] = 7 запаникует с index out of range [2] with length 0.

nil-слайсы и пустые слайсы

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	var a []int  // nil
	b := []int{} // empty, not nil

	fmt.Println(len(a), len(b), a == nil, b == nil)

	a = append(a, 1) // append works on nil
	fmt.Println(a)

	ja, _ := json.Marshal(struct{ Items []int }{})
	jb, _ := json.Marshal(struct{ Items []int }{Items: []int{}})
	fmt.Println(string(ja), string(jb))
}

nil-слайс ведёт себя как пустой для len, cap, range и append, поэтому как нулевое состояние лучше var s []T. Инициализируйте []T{}, только когда разница важна, а это в основном вывод JSON (null или []). Проверяйте пустоту через len(s) == 0, а не s == nil.

Слайсы и функции

Функция, получившая слайс, может менять его элементы, и вызывающий код увидит изменения. Изменить длину слайса вызывающего кода она не может, потому что получила копию заголовка. Функция, которая делает append, должна вернуть новый слайс:

func addAll(s []int, vals ...int) []int {
	return append(s, vals...)
}

Поэтому append, slices.Delete и slices.Insert все возвращают слайс.

Частые ошибки

Игнорирование результата append. Если выбросить его полностью, код не скомпилируется, но append(s, x), присвоенный другой переменной, а не той, которой вы продолжаете пользоваться, это логическая ошибка.
Два append от одной основы. Они могут делить хранилище. Клонируйте основу или используйте полное выражение среза.
make([]T, n), а затем append. В начале остаются n нулей.
Индекс за границами. s[len(s)] вызывает панику. Последний элемент это s[len(s)-1].
Сравнение слайсов через ==. Компилируется только s == nil. Используйте slices.Equal.

Часто задаваемые вопросы

Чем длина слайса отличается от ёмкости в Go?

len(s) это сколько элементов слайс содержит сейчас. cap(s) это сколько элементов помещается в базовом массиве, начиная с первого элемента слайса. append пишет в свободную ёмкость, если она есть, и выделяет новый массив большего размера, если её нет.

Как добавить элемент в слайс в Go?

Вызовите встроенную append и присвойте результат обратно: s = append(s, x). Можно добавить несколько значений (append(s, 1, 2, 3)) или другой слайс (append(s, other...)). Всегда используйте возвращаемое значение, потому что append может вернуть слайс, указывающий на новый массив.

Как удалить элемент из слайса в Go?

Используйте slices.Delete(s, i, i+1) (Go 1.21): она сдвигает последующие элементы и возвращает укороченный слайс. Начиная с Go 1.22 она ещё и обнуляет освободившиеся ячейки в хвосте. Если порядок не важен, поменяйте элемент местами с последним и обрежьте: s[i] = s[len(s)-1]; s = s[:len(s)-1].

Как проверить, содержит ли слайс значение, в Go?

Используйте slices.Contains(s, v) из стандартного пакета slices (Go 1.21). slices.Index(s, v) возвращает позицию или -1, а slices.ContainsFunc принимает предикат. Для многократных поисков по большим данным постройте мапу.

Чем nil-слайс отличается от пустого слайса в Go?

var s []int это nil; s := []int{} пустой, но не nil. У обоих длина 0, оба работают с len, range и append. Разница проявляется в проверках s == nil и в encoding/json, который кодирует nil-слайс как null, а пустой как [].

Связанные концепции