Часть 3. Данные и памятьУрок 09# go# коллекции# слайсы# собеседование

Массивы и слайсы

len и cap, append и переаллокация, общий массив, copy, утечки памяти

Цели главы

  • Объяснить разницу между массивом и слайсом — частый вопрос собеседования.
  • Создавать слайсы литералом, через make и нарезкой; понимать len и cap.
  • Понимать, когда append пишет в тот же массив, а когда переаллоцирует.
  • Копировать, удалять элементы и не ловить утечки памяти.

Зачем коллекции

Нужно хранить сто фильмов каталога — не заводить же film1, film2, film3. Коллекция складывает всё в одну переменную. В Go для последовательностей их два вида: массивы — жёсткие, размер не меняется; слайсы — гибкие, ими пользуются каждый день.

Массивы

Массив — коробка на фиксированное число ячеек: указал 5 — будет ровно 5. Три способа создать:

go
package main

import "fmt"

func main() {
    var a [5]int                           // пять нулей
    b := [3]string{"Go", "Python", "Rust"} // сразу с данными
    c := [...]int{1, 2, 3}                 // размер посчитает компилятор

    fmt.Println(a, b, c, len(c))
    a[1] = 99
    fmt.Println(a[0], a[1])

    for i, v := range b {
        fmt.Println(i, v)
    }
}
stdout // вывод программы
[0 0 0 0 0] [Go Python Rust] [1 2 3] 3
0 99
0 Go
1 Python
2 Rust
  • Индексы начинаются с нуля: первый элемент — a[0].
  • [...] не делает массив резиновым: размер всё равно фиксируется, просто его считает компилятор.
  • range сразу даёт индекс и значение — длину вручную считать не нужно.

Выход за границы

go
package main

import "fmt"

func main() {
    films := []string{"Дюна", "Матрица"}
    i := 5
    fmt.Println(films[i]) // ожидается panic
}

Программа падает с сообщением:

text
panic: runtime error: index out of range [5] with length 2

Почему массивы почти не используют

  1. Массив копируется целиком — при присваивании и при передаче в функцию. В массиве 10 000 элементов — скопируются все 10 000.
  2. Размер — часть типа. [3]int и [5]int — разные типы, один вместо другого не передать.
go
package main

import "fmt"

func resetFirst(arr [3]int) {
    arr[0] = 0 // меняем копию всего массива
}

func main() {
    a := [3]int{1, 2, 3}
    b := a // копия, а не ссылка
    b[0] = 100
    resetFirst(a)
    fmt.Println(a, b)
}
stdout // вывод программы
[1 2 3] [100 2 3]

Жёстко и неудобно — поэтому существуют слайсы.

Слайсы

Слайс — это окно поверх массива. Он знает три вещи: где лежит массив (указатель), сколько элементов сейчас видно (длина, len) и сколько поместится без переезда (ёмкость, cap). Аналогия: массив — книжная полка, слайс — рамка, которую двигаешь по полке, выбирая участок. Рамку можно сузить, расширить или переставить на новую полку побольше.

Пример: массив из 8 ячеек и слайс s := arr[2:6].

Индекс массива 0 1 2 3 4 5 6 7
Значение 10 20 30 40 50 60 70 80
Слайс s s[0] s[1] s[2] s[3] запас запас
  • len(s) = 4 — видны 4 элемента: 30, 40, 50, 60.
  • cap(s) = 6 — от начала слайса до конца массива 6 ячеек.
заголовок слайса sptr · len = 4 · cap = 6ptrмассив из 8 элементов1020304050607080len = 4cap = 6

Как создать слайс

Главное отличие от массива: в квадратных скобках нет числа.

go
package main

import "fmt"

func main() {
    arr := [8]int{10, 20, 30, 40, 50, 60, 70, 80}

    s1 := []int{1, 2, 3}     // литерал
    s2 := make([]int, 5)     // пять нулей
    s3 := make([]int, 0, 10) // пустой, но место на 10 элементов уже выделено
    s4 := arr[2:6]           // нарезка: индексы 2..5, правая граница не входит

    for _, s := range [][]int{s1, s2, s3, s4} {
        fmt.Printf("%v len=%d cap=%d\n", s, len(s), cap(s))
    }
}
stdout // вывод программы
[1 2 3] len=3 cap=3
[0 0 0 0 0] len=5 cap=5
[] len=0 cap=10
[30 40 50 60] len=4 cap=6

Нарезка удобна и для слайсов: первые три жанра для главной страницы — genres[:3], всё начиная с третьего — genres[2:], середина — genres[1:3].

append — добавление элементов

У append одно железное правило: результат всегда присваивают обратно: s = append(s, x). Причина — append может вернуть совсем другой слайс.

  • Если в массиве под слайсом есть свободное место, append дописывает элемент и увеличивает длину — массив тот же.
  • Если места нет, Go создаёт новый массив побольше, копирует туда старые данные и добавляет элемент. Слайс начинает указывать на новый массив.
go
package main

import "fmt"

func main() {
    s := make([]int, 0, 2)
    for i := 1; i <= 5; i++ {
        s = append(s, i) // результат append всегда присваиваем обратно
        fmt.Printf("%v len=%d cap=%d\n", s, len(s), cap(s))
    }

    more := []int{6, 7}
    s = append(s, more...) // три точки распаковывают слайс
    fmt.Println(s)
}
stdout // вывод программы
[1] len=1 cap=2
[1 2] len=2 cap=2
[1 2 3] len=3 cap=4
[1 2 3 4] len=4 cap=4
[1 2 3 4 5] len=5 cap=8
[1 2 3 4 5 6 7]

Видно, как ёмкость удваивается в момент переезда: 2 → 4 → 8. append(a, b...) — распаковка: как будто элементы b перечислили через запятую вручную.

Нарезка и общий массив

Самый частый баг новичков: нарезка не копирует данные. Новый слайс смотрит на тот же массив, поэтому изменение через один слайс видно через другой. Это не баг Go, а задумка — но если про неё не знать, будешь ловить странные ошибки.

Нужна независимая копия — создай слайс через make и скопируй данные функцией copy. Теперь это два отдельных массива.

go
package main

import "fmt"

func main() {
    original := []int{1, 2, 3, 4, 5}
    part := original[1:4] // [2 3 4] — тот же массив
    part[0] = 99
    fmt.Println(original) // оригинал изменился

    clone := make([]int, len(original))
    n := copy(clone, original) // копирует min(len(dst), len(src)) элементов
    clone[0] = -1
    fmt.Println(original, clone, n)
}
stdout // вывод программы
[1 99 3 4 5]
[1 99 3 4 5] [-1 99 3 4 5] 5

nil-слайс

Слайс, объявленный через var без инициализации, равен nil. Звучит страшно, но с ним можно нормально работать: длина 0, range проходит ноль раз, а append сам создаст массив при первом добавлении. Бояться nil-слайсов не нужно.

go
package main

import "fmt"

func main() {
    var films []string // nil-слайс: массива под капотом ещё нет
    fmt.Println(films == nil, len(films))
    films = append(films, "Дюна") // append сам создаст массив
    fmt.Println(films, films == nil)

    empty := []string{} // пустой, но не nil
    fmt.Println(empty == nil, len(empty))
}
stdout // вывод программы
true 0
[Дюна] false
false 0

Удаление элемента

Встроенной функции «удали элемент» в Go нет, но есть трюк через append: берёшь всё, что до удаляемого элемента, и склеиваешь с тем, что после.

go
package main

import (
    "fmt"
    "slices"
)

func main() {
    s := []string{"Боевик", "Мелодрама", "Хоррор", "Комедия"}
    i := 1 // удаляем «Мелодраму»
    s = append(s[:i], s[i+1:]...)
    fmt.Println(s)

    t := []string{"Боевик", "Мелодрама", "Хоррор", "Комедия"}
    t = slices.Delete(t, 1, 2) // то же через пакет slices (Go 1.21+)
    fmt.Println(t)

    orig := []int{1, 2, 3, 4}
    trimmed := append(orig[:1], orig[2:]...)
    fmt.Println(orig, trimmed) // исходный массив тоже изменился
}
stdout // вывод программы
[Боевик Хоррор Комедия]
[Боевик Хоррор Комедия]
[1 3 4 4] [1 3 4]

s[:i] — всё до индекса i, s[i+1:] — всё после него; три точки распаковывают второй кусок, и элемент с индексом i просто не попадает в результат.

Что под капотом

Без этого многие вещи кажутся магией, и это любимая тема собеседований. Слайс — не сам массив, а маленькая структура из трёх полей: указатель на массив, длина и ёмкость. На 64-битной системе она занимает 24 байта, а сам массив живёт отдельно.

Отсюда ответы на частые вопросы:

  • Почему передавать слайс в функцию дёшево? Копируются только 24 байта заголовка — сколько бы элементов ни было: тысяча или миллион.
  • Почему изменение элемента в функции видно снаружи, а append — нет? У функции своя копия заголовка, но указатель в ней смотрит на тот же массив. Запись s[0] = 999 идёт в общий массив. А append меняет длину (и, возможно, указатель) только в локальном заголовке.
go
package main

import (
    "fmt"
    "unsafe"
)

func modify(s []int) {
    s[0] = 999       // пишем в общий массив — видно снаружи
    s = append(s, 4) // меняется только локальный заголовок — не видно снаружи
}

func addFilm(s []int, v int) []int {
    return append(s, v) // идиоматично: вернуть новый слайс
}

func main() {
    s := []int{1, 2, 3}
    modify(s)
    fmt.Println(s)

    s = addFilm(s, 4)
    fmt.Println(s)
    fmt.Println("размер заголовка:", unsafe.Sizeof(s), "байта")
}
stdout // вывод программы
[999 2 3]
[999 2 3 4]
размер заголовка: 24 байта

Чтобы добавление было видно снаружи, есть два варианта: вернуть новый слайс из функции или передать указатель на слайс. Первый — идиоматичный.

заголовок в mainlen = 3 · cap = 3копия заголовка в modifylen = 3 · cap = 3общий массив999 · 2 · 3новый массив999 · 2 · 3 · 4ptrptrappend: cap не хватило

Стратегия роста

Когда append не хватает места, Go выделяет массив с запасом. Раньше правило было простым — удвоить. Сейчас стратегия умнее: маленькие слайсы растут примерно вдвое, большие — медленнее, чтобы не тратить лишнюю память.

Зачем это знать? Чтобы заранее делать make с ёмкостью, когда размер известен. Если в слайсе будет 1000 элементов, а cap не указан, append переаллоцирует массив около десяти раз, и каждый раз копирует все данные. Указал cap сразу — ноль переаллокаций.

Утечка памяти при нарезке

Ловит даже опытных. Есть огромный массив на миллион элементов, из него сделали маленький слайс на 10. Кажется, что Go освободит память большого массива. Нет: маленький слайс держит указатель на тот же массив, и сборщик мусора не может его убрать.

go
func getFirst10(huge []int) []int {
    return huge[:10] // держит в памяти весь массив huge
}

func getFirst10Safe(huge []int) []int {
    result := make([]int, 10)
    copy(result, huge[:10]) // копия — большой массив соберёт GC
    return result
}

Практика

Домашнее задание

  1. Сумма. Напиши func sum(nums []int) int — сумму элементов. Проверь на пустом слайсе и на nil-слайсе.
  2. Удаление дубликатов. Напиши removeDuplicates(s []string) []string — новый слайс без повторов, порядок сохраняется. Пригодится мапа из следующей главы, но сначала реши без неё.
  3. Фильтр для каталога. Есть слайс рейтингов фильмов. Напиши filterByRating(ratings []float64, minRating float64) []float64, которая возвращает рейтинги выше порога. Используй make с cap.
решениеЭталонное решение
go
package main

import "fmt"

func sum(nums []int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

func removeDuplicates(s []string) []string {
    result := make([]string, 0, len(s))
    for _, v := range s {
        seen := false
        for _, r := range result {
            if r == v {
                seen = true
                break
            }
        }
        if !seen {
            result = append(result, v)
        }
    }
    return result
}

func filterByRating(ratings []float64, minRating float64) []float64 {
    result := make([]float64, 0, len(ratings)) // ёмкость с запасом — без переаллокаций
    for _, r := range ratings {
        if r > minRating {
            result = append(result, r)
        }
    }
    return result
}

func main() {
    var nilSlice []int
    fmt.Println(sum([]int{1, 2, 3}), sum([]int{}), sum(nilSlice))
    fmt.Println(removeDuplicates([]string{"Дюна", "Матрица", "Дюна", "Довод", "Матрица"}))
    fmt.Println(filterByRating([]float64{7.2, 9.1, 6.5, 8.8, 5.3}, 7.0))
}
stdout // вывод программы
6 0 0
[Дюна Матрица Довод]
[7.2 9.1 8.8]

removeDuplicates с вложенным циклом работает за O(n²); с мапой — за O(n).

Тренировка: предскажи вывод

go
package main

import "fmt"

func main() {
    a := []int{1, 2, 3, 4}
    b := a[:2]
    b = append(b, 99)
    fmt.Println(a, b, len(b), cap(b))
}
самопроверкаОтвет
text
[1 2 99 4] [1 2 99] 3 4

b — окно над тем же массивом с ёмкостью 4. Места хватает, поэтому append записал 99 прямо в a[2].

Проверь себя

вопросЧем слайс отличается от массива?

У массива фиксированный размер, который входит в тип ([3]int ≠ [5]int), и он копируется целиком. Слайс — заголовок (указатель, len, cap) над массивом: размер динамический, копируется только заголовок.

вопросЧто хранит заголовок слайса и сколько он весит?

Указатель на массив, длину и ёмкость — 24 байта на 64-битной системе.

вопросПочему результат append всегда присваивают обратно?

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

вопросФункция получила слайс и сделала s[0] = 1 и s = append(s, 2). Что увидит вызывающий код?

Изменение s[0] — да: запись идёт в общий массив. Новый элемент — нет: append изменил только локальную копию заголовка.

вопросКак сделать независимую копию слайса?

clone := make([]T, len(s)) и copy(clone, s) — или slices.Clone(s).

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

У nil-слайса нет массива под капотом и он равен nil, у пустого массив есть. Оба имеют длину 0, с обоими работают range и append. Разница видна в JSON: null против [].

вопросКак может возникнуть утечка памяти при нарезке и как её избежать?

Маленький слайс от огромного массива держит весь массив, и GC не может его освободить. Нужно скопировать нужную часть в новый слайс.

вопросЗачем указывать ёмкость в make([]T, 0, n)?

Чтобы append не переаллоцировал массив по мере роста — это экономит копирования и память.


Ключевые выводы

  • 📦 Массив — фиксированный размер в типе и копирование целиком; на практике работают со слайсами.
  • 🪟 Слайс — 24-байтный заголовок (ptr, len, cap) поверх массива.
  • ➕ s = append(s, x): при нехватке cap создаётся новый массив, поэтому результат присваивают обратно.
  • 🔗 Нарезка делит массив: изменения видны через все слайсы; независимая копия — copy или slices.Clone.
  • 📈 Ёмкость растёт ×2 до 256 элементов, потом медленнее; известен размер — делай make с cap.
  • 🧲 Маленький слайс от большого массива держит его в памяти — копируй нужную часть.
// связанные темы и шпаргалки