Что выгоднее передать в функцию, с точки зрения памяти: слайс или массив?

Краткий ответ

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

Фундаментальные различия: массив vs слайс

Массив

Массив в Go — это составной тип данных, представляющий собой неизменяемую последовательность элементов фиксированной длины, расположенных в непрерывной области памяти.

// Массив из 5 целых чисел
var arr [5]int = [5]int{1, 2, 3, 4, 5}

Ключевые особенности массива:

• Размер — часть типа данных. [5]int и [10]int — это разные, несовместимые типы.
• Передается по значению. При передаче массива в функцию создается полная копия всех его элементов.
• Размер известен на этапе компиляции.

Слайс

Слайс — это "динамическое окно" или дескриптор, предоставляющий доступ к непрерывному сегменту лежащего в его основе массива (underlying array).

// Слайс, указывающий на массив
slice := []int{1, 2, 3, 4, 5}

Структура слайса (примерное представление) включает три компонента:

type sliceHeader struct {
    Pointer uintptr // Указатель на первый элемент базового массива
    Length  int     // Текущая длина слайса
    Capacity int    // Емкость (максимальная длина без реаллокации)
}

Анализ передачи в функцию

Передача массива

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

func processArray(arr [1000000]int64) {
    // Здесь работает с КОПИЕЙ миллиона элементов
    arr[0] = 999 // Изменение не затронет оригинальный массив
}

func main() {
    var bigArray [1000000]int64
    processArray(bigArray) // Дорогая операция копирования!
}

Плюсы передачи массива:

• Защита данных: Функция не может нечаянно изменить исходные данные.
• Локальность данных: Кэш процессора работает эффективнее с непрерывным блоком памяти, которым является копия массива внутри функции.

Минусы:

• Высокие затраты на копирование для больших массивов.
• Непрактичность для работы с данными переменного размера.

Передача слайса

При передаче слайса копируется только дескриптор (sliceHeader — указатель + два целых числа), обычно это 24 байта на 64-битных системах. Копирование происходит мгновенно (O(1)), независимо от размера лежащего в основе массива.

func processSlice(sl []int64) {
    // Работает с тем же базовым массивом, что и оригинальный слайс
    sl[0] = 999 // Это изменение видно снаружи функции!
}

func main() {
    bigSlice := make([]int64, 1000000)
    processSlice(bigSlice) // Дешево: копируется только 24 байта
}

Плюсы передачи слайса:

• Эффективность: Постоянные и минимальные затраты на передачу.
• Гибкость: Естественный способ работы с коллекциями переменного размера.
• Совместимость: Интерфейсы стандартной библиотеки Go рассчитаны на слайсы.

Минусы (и важные нюансы):

• Неявное изменение данных: Функция может модифицировать элементы исходного массива. Если это нежелательно, можно передать копию слайса (append([]T{}, originalSlice...)) или работать аккуратно.
• Слайс — это не "указатель на массив". Хотя дескриптор содержит указатель, сам дескриптор передается по значению. Это значит, что изменения Length, Capacity или переназначение указателя внутри функции (sl = anotherSlice) не видны снаружи, но изменения элементов массива, на которые он указывает, — видны.

func modifySlice(s []int) {
    s[0] = 100        // Видно снаружи: меняется элемент базового массива
    s = append(s, 50) // НЕ видно снаружи: меняется локальная копия дескриптора
}

Практические рекомендации

1. Используйте слайсы по умолчанию. В 99% случаев в Go для передачи коллекций в функции используются слайсы. Это идиоматично и эффективно.
2. Рассматривайте массивы в особых случаях:

    *   Когда размер коллекции **строго фиксирован** и является важной частью семантики типа (например, координата `[3]float64`, матрица `[4][4]float32`).
    *   Когда вам **критически важна предсказуемость** расположения данных в памяти для оптимизации (например, при интенсивных низкоуровневых вычислениях).
    *   Когда вы **сознательно хотите избежать** побочных эффектов от модификации данных функцией, а стоимость копирования приемлема (для небольших массивов).

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

Итог

Слайс является механизмом передачи, оптимизированным для производительности. Его передача в функцию требует копирования всего 3 машинных слов. Массив же копирует N элементов. Для больших данных это делает передачу массива невыгодной.

Однако выбор между ними — это чаще вопрос дизайна API и семантики, а не микрооптимизации. Слайс — это абстракция для работы с последовательностями в Go, и ее следует предпочитать. Массивы — это низкоуровневые строительные блоки, используемые в основе слайсов и в специфических сценариях, где их статическая природа является преимуществом.