---
title: Массивы и слайсы
seo:
title: Массивы и слайсы — Go Developer
description: Тема «Массивы и слайсы» для собеседования Go Developer. Что такое слайс (slice) и массив (array)? Чем отличается массив от слайса? Как устроен слайс в Go?
---
[Все темы Go Developer](/go-developer)
## Что такое слайс (slice) и массив (array)? Чем отличается массив от слайса? [#q-14bee738d69b812695e4db6ec6e38a8c]
Массивы и слайсы имеют свои преимущества и недостатки.
#### Массив (Array) в Go:
- Определение: Статически типизированная структура данных с
фиксированным размером.
- Объявление: Размер массива указывается при его создании.
- Пример:
```go
var arr [5]int
arr = [5]int{1, 2, 3, 4, 5}
```
#### Слайс (Slice) в Go:
- Определение: Статически типизированный срез базового массива. Длина слайса может меняться, а тип его элементов задается при компиляции.
- Объявление: Размер слайса не фиксирован и может
изменяться.
- Пример:
```go
var slice []int
slice = []int{1, 2, 3, 4, 5}
```
#### Основные отличия:
{/* prettier-ignore */}
1. Размер:
- Массив: Фиксированный размер, определяемый при создании.
- Слайс: Динамический размер, может изменяться в ходе выполнения программы.
1. Гибкость:
- Массив: Менее гибкий из-за фиксированного размера.
- Слайс: Более гибкий, поддерживает добавление и удаление элементов.
1. Создание:
- Массив: var arr [5]int
- Слайс: var slice []int или с помощью функции make: slice := make([]int, 5)
1. Использование и расширение:
- Массив: Не может быть изменен в размере после создания.
- Слайс: Можно изменять с помощью встроенных функций, таких как append.
:::note[Ссылки для изучения]
1. [Массивы и слайсы в Golang](https://habr.com/ru/articles/739754/)
:::
---
## Как устроен слайс в Go? [#q-14bee738d69b817fa885cfc262e18eea]
Слайс в Go — это динамическая структура данных, представляющая собой секцию (или "срез") массива. Слайсы более гибкие, чем массивы, и поддерживают динамическое изменение размера.
#### Основные характеристики:
{/* prettier-ignore */}
1. Гибкость размера:
- Размер слайса может изменяться в ходе выполнения программы.
- Пример: slice := []int{1, 2, 3} создает слайс из 3 элементов, к которому можно добавить новые элементы.
1. Поддержка операций добавления и удаления:
- Можно добавлять элементы с помощью функции append.
- Пример: slice = append(slice, 4) добавляет элемент в слайс.
1. Индексация и длина:
- Доступ к элементам осуществляется по индексу, как в массиве.
- Длина слайса определяется функцией len(slice).
- Пример: fmt.Println(slice[0]) и fmt.Println(len(slice)).
1. Подкапотное устройство:
- Слайс содержит указатель на массив, длину (len) и вместимость (cap).
- Вместимость (capacity) определяет количество элементов, которые слайс может содержать без выделения новой памяти.
#### Пример кода:
```go
package main
import "fmt"
func main() {
// Создание слайса с начальной длиной и емкостью
slice := []int{1, 2, 3}
// Добавление элементов в слайс
slice = append(slice, 4, 5)
// Доступ к элементам слайса
fmt.Println(slice[0]) // Вывод: 1
// Длина и емкость слайса
fmt.Println("Length:", len(slice)) // Вывод: Length: 5
fmt.Println("Capacity:", cap(slice)) // Вывод: Capacity: 6 (емкость может варьироваться)
}
```
Слайсы в Go обеспечивают удобную работу с динамическими коллекциями данных, предоставляя гибкость и простоту использования.
:::note[Ссылки для изучения]
1. [Массивы и слайсы в Golang](https://habr.com/ru/articles/739754/)
:::
---
## Как устроен массив в Go? [#q-14bee738d69b81da8581e09a0407713e]
Массив в Go — это статически типизированная структура данных с фиксированным размером. Он состоит из элементов одного типа, расположенных последовательно в памяти.
#### Основные характеристики:
{/* prettier-ignore */}
1. Фиксированный размер:
- Размер массива определяется при его создании и не может быть изменен.
- Пример: var arr [5]int создает массив из 5 целых чисел.
1. Статическая типизация:
- Тип элементов массива задается при объявлении.
- Пример: var arr [3]string создает массив из 3 строк.
1. Индексация:
- Доступ к элементам массива осуществляется по индексу, начиная с 0.
- Пример: arr[0] доступ к первому элементу массива.
1. Инициализация:
- Массив можно инициализировать при создании.
- Пример: arr := [3]int{1, 2, 3}
#### Пример кода:
```go
package main
import "fmt"
func main() {
// Объявление и инициализация массива
var arr [5]int = [5]int{1, 2, 3, 4, 5}
// Доступ к элементам массива
fmt.Println(arr[0]) // Вывод: 1
// Изменение элемента массива
arr[2] = 10
fmt.Println(arr) // Вывод: [1 2 10 4 5]
}
```
Массивы в Go используются реже, чем слайсы, из-за своей фиксированной природы и ограниченной гибкости.
:::note[Ссылки для изучения]
1. [Массивы и слайсы в Golang](https://habr.com/ru/articles/739754/)
:::
---
## Как можно создать слайс? [#q-14bee738d69b8157bcfae5a41e21952c]
В Go слайс можно создать несколькими способами:
1. Создание слайса с помощью литерала:
```go
slice := []int{1, 2, 3}
```
1. Создание пустого слайса и его инициализация:
```go
var slice []int
slice = append(slice, 1, 2, 3)
```
1. Использование функции make:
```go
slice := make([]int, 5) // Создание слайса с длиной 5 и нулевыми значениями
sliceWithCapacity := make([]int, 5, 10) // Слайс длиной 5 и емкостью 10
```
1. Создание слайса из массива:
```go
array := [5]int{1, 2, 3, 4, 5}
slice := array[1:4] // Слайс включает элементы с 1-го по 3-й индексы (2, 3, 4)
```
#### Примеры:
1. Слайс с литералом:
```go
slice := []string{"apple", "banana", "cherry"}
```
1. Пустой слайс с инициализацией:
```go
var slice []int
slice = append(slice, 10, 20, 30)
```
1. Слайс с make:
```go
slice := make([]int, 5) // Создание слайса длиной 5
sliceWithCapacity := make([]int, 5, 10) // Создание слайса длиной 5 и емкостью 10
```
1. Слайс из массива:
```go
array := [5]int{1, 2, 3, 4, 5}
slice := array[1:4] // Слайс содержит [2 3 4]
```
Эти способы позволяют создавать слайсы для различных нужд, обеспечивая гибкость и удобство работы с данными в Go.
:::note[Ссылки для изучения]
1. [Массивы и слайсы в Golang](https://habr.com/ru/articles/739754/)
:::
---
## Что такое zero-value и какое оно у слайса? [#q-14bee738d69b816dbc9ddec5b92d604c]
Zero-value — это значение по умолчанию, которое присваивается
переменной, когда она объявлена, но не инициализирована явно. Для каждого типа в
Go существует свое zero-value.
#### Zero-value для слайса:
Для слайсов zero-value — это nil и длина равная 0.
#### Пример:
```go
var slice []int // zero-value для слайса
fmt.Println(slice == nil) // true
fmt.Println(len(slice)) // 0
```
В этом примере slice имеет zero-value, что означает, что он nil и его длина равна 0. Слайс с zero-value можно использовать, например, в функциях append, и он будет работать корректно.
:::note[Ссылки для изучения]
1. [Массивы и слайсы в Golang](https://habr.com/ru/articles/739754/)
:::
---
## Что такое nil slice и чем отличается? Можно ли добавлять элементы в nil slice? [#q-14bee738d69b815b96abd3651d4dc88c]
nil slice — это слайс, который не указывает на какой-либо массив,
его zero-value. nil slice имеет длину и емкость равные нулю.
#### Отличия nil slice:
{/* prettier-ignore */}
1. Инициализация:
- Nil слайс: не инициализирован и равен nil.
- Пустой слайс: инициализирован, но не содержит элементов, например, созданный с помощью make([]int, 0).
1. Проверка на nil:
- Можно проверить, является ли слайс nil с помощью сравнения с nil.
#### Пример:
```go
var nilSlice []int // nil слайс
emptySlice := make([]int, 0) // пустой слайс
fmt.Println(nilSlice == nil) // true
fmt.Println(emptySlice == nil) // false
```
#### Добавление элементов в nil slice:
Да, можно добавлять элементы в nil slice с помощью функции append. При этом Go автоматически выделит память для слайса.
#### Пример добавления в nil slice:
```go
var nilSlice []int
nilSlice = append(nilSlice, 1, 2, 3)
fmt.Println(nilSlice) // [1 2 3]
```
В этом примере элементы успешно добавляются в nil слайс, и Go корректно обрабатывает выделение памяти.
:::note[Ссылки для изучения]
1. [Массивы и слайсы в Golang](https://habr.com/ru/articles/739754/)
:::
---
## Как проверить слайс на пустоту? [#q-14bee738d69b816f815fe651c97ee9ea]
Пример проверки слайса на пустоту:
```go
var slice []int
if len(slice) == 0 {
fmt.Println("Slice is empty")
} else {
fmt.Println("Slice is not empty")
}
```
В этом примере, если длина слайса slice равна нулю, выводится сообщение "Slice is empty".
:::note[Ссылки для изучения]
1. [Массивы и слайсы в Golang](https://habr.com/ru/articles/739754/)
:::
---
## Как работает базовая функция append для слайсов? Можно ли применить к массивам? Напишите свою функцию append [#q-14bee738d69b816888e2de185dfa211c]
Функция append в Go добавляет элементы к слайсу, расширяя его при необходимости. Если текущая емкость слайса недостаточна, создается новый массив большего размера, копируются существующие элементы и добавляются новые.
#### Пример использования append:
```go
slice := []int{1, 2, 3}
slice = append(slice, 4, 5)
fmt.Println(slice) // Вывод: [1 2 3 4 5]
```
#### Применение к массивам:
Функцию append нельзя применить непосредственно к массивам, так как она предназначена только для слайсов. Но можно создать слайс на основе массива и затем использовать append.
#### Пример функции append:
```go
package main
import "fmt"
func myAppend(slice []int, elements ...int) []int {
oldLen := len(slice)
newLen := oldLen + len(elements)
if newLen > cap(slice) {
grown := make([]int, newLen)
copy(grown, slice)
slice = grown
} else {
slice = slice[:newLen]
}
copy(slice[oldLen:], elements)
return slice
}
func main() {
slice := []int{1, 2, 3}
slice = myAppend(slice, 4, 5)
fmt.Println(slice) // Вывод: [1 2 3 4 5]
}
```
В этом примере функция myAppend добавляет элементы к слайсу и возвращает обновленный слайс.
:::note[Ссылки для изучения]
1. [Массивы и слайсы в Golang](https://habr.com/ru/articles/739754/)
:::
---
## Как можно добавить элементы в слайс? Что будет если элемент не вмещается в размер слайса? [#q-14bee738d69b819f8e4ae2d9e20f8456]
В Go для добавления элементов в слайс используется функция append.
#### Пример добавления элементов:
```go
slice := []int{1, 2, 3}
slice = append(slice, 4, 5)
fmt.Println(slice) // Вывод: [1 2 3 4 5]
```
#### Что происходит, если элемент не вмещается в размер слайса:
Если текущая емкость слайса недостаточна для добавления новых элементов, Go автоматически выделяет новый массив большего размера, копирует в него существующие элементы и добавляет новые. Емкость нового массива обычно увеличивается с некоторым запасом для уменьшения количества перераспределений памяти в будущем.
#### Пример с недостаточной емкостью:
```go
slice := make([]int, 3, 3) // Создание слайса длиной 3 и емкостью 3
slice[0], slice[1], slice[2] = 1, 2, 3
slice = append(slice, 4) // Добавление нового элемента, перераспределение памяти
fmt.Println(slice) // Вывод: [1 2 3 4]
```
В этом примере начальная емкость слайса равна 3. При добавлении четвертого элемента Go перераспределяет память и увеличивает емкость слайса.
:::note[Ссылки для изучения]
1. [Массивы и слайсы в Golang](https://habr.com/ru/articles/739754/)
:::
---
## Как можно слить два слайса? [#q-14bee738d69b81a1941de8469737ef31]
В Go можно слить два слайса с помощью функции append. Просто передайте второй слайс как аргументы к append с помощью ....
#### Пример слияния двух слайсов:
```go
slice1 := []int{1, 2, 3}
slice2 := []int{4, 5, 6}
mergedSlice := append(slice1, slice2...)
fmt.Println(mergedSlice) // Вывод: [1 2 3 4 5 6]
```
#### Объяснение:
- slice2... распаковывает элементы второго слайса,
позволяя append добавить их к первому слайсу.
- Результат append нужно сохранить: он возвращает слайс с новой длиной. Если емкости достаточно, результат использует прежний базовый массив и может изменить данные других слайсов на тот же массив.
:::note[Ссылки для изучения]
1. [Массивы и слайсы в Golang](https://habr.com/ru/articles/739754/)
:::
---
## Как получить срез слайса и избежать ошибок с общим массивом? [#q-14bee738d69b814a8ca3d2590beb1992]
Для нарезки слайса используется синтаксис slice[start:end], где start — начальный индекс (включительно), а end — конечный индекс (исключительно).
#### Примеры нарезки:
```go
slice := []int{1, 2, 3, 4, 5}
subslice1 := slice[1:3] // содержит элементы с индексами 1 и 2: [2 3]
subslice2 := slice[:2] // содержит первые два элемента: [1 2]
subslice3 := slice[2:] // содержит элементы с индекса 2 до конца: [3 4 5]
```
#### Нюансы и подводные камни:
1. Общие данные: Нарезка слайса создает новый слайс,
который ссылается на тот же базовый массив. Изменения в одном слайсе могут
повлиять на другой.
```go
slice := []int{1, 2, 3, 4, 5}
subslice := slice[1:3]
subslice[0] = 10
fmt.Println(slice) // Вывод: [1 10 3 4 5]
```
1. Ограничения по индексам: для слайса s выражение s\[low:high\] требует 0 ≤ low ≤ high ≤ cap(s). Верхняя граница может превышать len(s); нарушение границ вызывает панику.
```go
slice := []int{1, 2, 3, 4, 5}
// subslice := slice[1:6] // panic: runtime error: slice bounds out of range
```
1. Изменение длины и емкости: Нарезанный слайс имеет свою
длину и емкость, которая может быть меньше или равна емкости исходного
слайса.
```go
slice := []int{1, 2, 3, 4, 5}
subslice := slice[1:3]
fmt.Println(len(subslice)) // Вывод: 2
fmt.Println(cap(subslice)) // Вывод: 4: cap(slice) - 1
```
Нарезка слайсов в Go удобна, но требует внимательного отношения к изменениям базового массива и индексам.
:::note[Ссылки для изучения]
1. [Массивы и слайсы в Golang](https://habr.com/ru/articles/739754/)
:::
---
## Как можно скопировать слайс? Что такое функция copy? Как добиться аналогичного поведения copy с помощью append? [#q-14bee738d69b81928e6fc7b57a26bad2]
Для копирования слайсов можно использовать встроенную функцию copy.
Функция copy копирует элементы из одного слайса в другой. Возвращает количество скопированных элементов.
```go
src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src)
fmt.Println(dst) // Вывод: [1 2 3]
```
Для достижения аналогичного поведения функции copy можно использовать append:
```go
src := []int{1, 2, 3}
dst := append([]int(nil), src...)
fmt.Println(dst) // Вывод: [1 2 3]
```
В этом примере создается новый слайс []int(nil), к которому добавляются все элементы из src с помощью append.
:::note[Ссылки для изучения]
1. [Массивы и слайсы в Golang](https://habr.com/ru/articles/739754/)
:::