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

Методы объединения слайсов в Go

В Go существует несколько способов объединения двух слайсов, каждый из которых имеет свои особенности и варианты использования. Основное различие между подходами заключается в том, создаётся ли новая копия данных или происходит манипуляция с существующими слайсами.

1. Оператор append() - основной способ

Наиболее распространённый и идиоматичный способ объединения слайсов:

package main

import "fmt"

func main() {
    slice1 := []int{1, 2, 3}
    slice2 := []int{4, 5, 6}
    
    // Базовый способ с оператором spread (...)
    combined := append(slice1, slice2...)
    
    fmt.Println(combined) // [1 2 3 4 5 6]
}

Важные особенности:

• Используется оператор ... для "распаковки" второго слайса
• Создаётся новый слайс с элементами из обоих исходных слайсов
• Если slice1 имеет достаточную capacity, будет использован существующий массив

2. Объединение нескольких слайсов

Оператор append() может объединять более двух слайсов:

func main() {
    a := []string{"A", "B"}
    b := []string{"C", "D"}
    c := []string{"E", "F"}
    
    result := append(append(a, b...), c...)
    // Или более читаемо:
    result := []string{}
    result = append(result, a...)
    result = append(result, b...)
    result = append(result, c...)
}

3. Ручное копирование с make() и copy()

Полезно, когда нужно контролировать capacity или избегать лишних аллокаций:

func combineSlices(slice1, slice2 []int) []int {
    // Создаём слайс с нужным размером
    result := make([]int, len(slice1) + len(slice2))
    
    // Копируем элементы
    copy(result, slice1)
    copy(result[len(slice1):], slice2)
    
    return result
}

Преимущества этого подхода:

• Контроль над capacity результирующего слайса
• Избегание возможных реаллокаций при последовательных append()
• Предсказуемое потребление памяти

4. Использование циклов (для обработки элементов)

Если нужно выполнить дополнительные операции во время объединения:

func combineWithTransformation(slice1, slice2 []int) []int {
    result := make([]int, 0, len(slice1) + len(slice2))
    
    for _, v := range slice1 {
        result = append(result, v*2) // Пример трансформации
    }
    
    for _, v := range slice2 {
        result = append(result, v*2)
    }
    
    return result
}

5. Обобщённый вариант с дженериками (Go 1.18+)

С появлением дженериков можно создать универсальную функцию:

func Concatenate[T any](slices ...[]T) []T {
    totalLen := 0
    for _, s := range slices {
        totalLen += len(s)
    }
    
    result := make([]T, totalLen)
    offset := 0
    
    for _, s := range slices {
        copy(result[offset:], s)
        offset += len(s)
    }
    
    return result
}

// Использование:
// combined := Concatenate(slice1, slice2, slice3)

Критические аспекты для рассмотрения

Вопросы производительности:

• append() с spread оператором обычно достаточно быстр для большинства случаев
• Предварительное выделение capacity (через make()) может улучшить производительность при объединении больших слайсов
• Избегайте многократного вызова append() в циклах для больших данных

Вопросы безопасности и побочных эффектов:

slice1 := []int{1, 2, 3}
slice2 := []int{4, 5, 6}

combined := append(slice1, slice2...)
// Изменение combined[0] НЕ повлияет на slice1[0]
// Но если capacity slice1 было достаточно, могут быть неожиданности:
slice3 := make([]int, 3, 10) // capacity = 10
slice4 := []int{7, 8, 9}
combined2 := append(slice3, slice4...)
// В этом случае combined2 использует тот же массив, что и slice3

Рекомендации по выбору метода:

1. Для простых случаев - используйте append(slice1, slice2...)
2. Для объединения многих слайсов - создавайте слайс с нужной capacity
3. Для критического к производительности кода - используйте make() + copy()
4. При работе с пустыми или nil слайсами - append() корректно обрабатывает nil слайсы

Особый случай: объединение с сохранением capacity

func combineWithExactCapacity(a, b []int) []int {
    total := len(a) + len(b)
    result := make([]int, total, total) // capacity = length
    copy(result[:len(a)], a)
    copy(result[len(a):], b)
    return result
}

Итог: выбор метода зависит от конкретного сценария использования. Для большинства повседневных задач append() с spread оператором является оптимальным выбором благодаря своей простоте и читаемости. Для оптимизированного кода или работы с большими объёмами данных предпочтительнее использовать подход с явным управлением памятью через make() и copy().