Слайсы из срезов — Основы Go

• Как работает слайсинг [:]
• Примеры
• Отрезание элементов
• Вложенные срезы
• Выход за пределы
• Использование [:] для "удаления" элементов
  • Удаление первого элемента
  • Удаление последнего элемента
  • Удаление диапазона элементов
• Кратко

В Go есть удобная операция слайсинг (slicing), которая используется для получения поднабора элементов из среза. С помощью конструкции [:] можно указать диапазон элементов, создавая новый срез, который ссылается на тот же базовый массив. При этом операция не копирует данные, а лишь формирует новое «окно» на существующий массив.

Как работает слайсинг [:]

Синтаксис:

s[начало:конец]

• начало — индекс, с которого начинается срез (включительно).
• конец — индекс, на котором срез заканчивается (не включительно).
• Если начало не указано — берется 0.
• Если конец не указан — берется len(s).

Примеры

s := []int{10, 20, 30, 40, 50}

fmt.Println(s[:])     // => [10 20 30 40 50]
fmt.Println(s[1:4])   // => [20 30 40]
fmt.Println(s[:3])    // => [10 20 30]
fmt.Println(s[2:])    // => [30 40 50]

Отрезание элементов

Срезы позволяют легко отбросить первый или последний элемент:

s := []string{"a", "b", "c", "d"}

s = s[1:]             // убираем первый элемент
fmt.Println(s)        // => [b c d]

s = s[:len(s)-1]      // убираем последний элемент
fmt.Println(s)        // => [b c]

Вложенные срезы

Так как [:] возвращает новый срез, можно использовать его в цепочках:

s := []int{1, 2, 3, 4, 5}
middle := s[1:4]   // [2 3 4]
tail := middle[1:] // [3 4]
fmt.Println(tail)  // => [3 4]

Важно: все срезы указывают на один и тот же базовый массив. Изменение элемента в одном срезе повлияет на другие.

s := []int{1, 2, 3, 4}
sub := s[1:3]  // [2 3]
sub[0] = 99
fmt.Println(s) // => [1 99 3 4]

Выход за пределы

Если задать границы, выходящие за пределы длины среза, будет паника времени выполнения:

s := []int{1, 2, 3}
fmt.Println(s[1:5])   // panic: slice bounds out of range

Использование [:] для "удаления" элементов

В Go нет встроенной функции для удаления элементов из среза, но [:] позволяет легко получить новый срез без нужных элементов.

Удаление первого элемента

s := []string{"a", "b", "c", "d"}
s = s[1:]
fmt.Println(s) // => [b c d]

Удаление последнего элемента

s := []string{"a", "b", "c", "d"}
s = s[:len(s)-1]
fmt.Println(s) // => [a b c]

Удаление диапазона элементов

Можно отбросить несколько элементов, используя append() вместе с [:]:

s := []string{"a", "b", "c", "d", "e"}
s = append(s[:1], s[3:]...)
fmt.Println(s) // => [a d e]

Конструкция [:] в таких примерах не копирует данные, а создаёт новый срез с нужным диапазоном, сохраняя общую память с исходным массивом.

Кратко