В чем особенность функции copy в Go?

Особенности функции copy в Go

Функция copy в Go — это встроенная функция для копирования данных между срезами (slices) или из строки в срез байт ([]byte) или рун ([]rune). Её ключевая особенность в том, что она работает на уровне памяти, обеспечивая эффективное копирование без лишних аллокаций.

Основное поведение и синтаксис

Сигнатура функции:

func copy(dst, src []Type) int

• dst — целевой срез, куда копируются данные.
• src — исходный срез или строка, откуда берутся данные.
• Возвращает количество скопированных элементов (минимум из len(dst) и len(src)).

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

1. Копирование только доступного пространства

Функция копирует элементы без изменения размера целевого среза. Она работает в пределах текущих длин (len) срезов:

package main

import "fmt"

func main() {
    src := []int{1, 2, 3, 4, 5}
    dst := make([]int, 3) // len=3
    
    copied := copy(dst, src)
    fmt.Printf("Скопировано %d элементов: %v\n", copied, dst)
    // Вывод: Скопировано 3 элемента: [1 2 3]
}

2. Безопасное перекрытие областей памяти

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

package main

import "fmt"

func main() {
    data := []int{1, 2, 3, 4, 5}
    // Копируем в пределах одного базового массива
    copy(data[2:], data[1:4])
    fmt.Println(data) // Вывод: [1 2 2 3 4]
}

3. Работа со строками

Особая возможность — копирование из строки в срез байт или рун:

package main

import "fmt"

func main() {
    str := "Привет"
    
    // Копирование в срез байт
    bytes := make([]byte, 10)
    n := copy(bytes, str)
    fmt.Printf("Скопировано %d байт: %v\n", n, bytes[:n])
    
    // Копирование в срез рун
    runes := make([]rune, 10)
    n = copy(runes, str)
    fmt.Printf("Скопировано %d рун: %v\n", n, runes[:n])
}

4. Эффективность и производительность

• copy компилируется в низкоуровневую операцию копирования памяти (аналог memmove в C)
• Не создаёт новых аллокаций
• Оптимизирована для работы с различными типами данных

Сравнение с другими подходами

Через цикл:

// Менее эффективно
for i := 0; i < len(src) && i < len(dst); i++ {
    dst[i] = src[i]
}

Через append:

// Создаёт новый срез, может вызывать аллокации
dst = append([]T{}, src...)

Практические сценарии использования

1. Сдвиг элементов в срезе

// Удаление элемента по индексу i
copy(slice[i:], slice[i+1:])
slice = slice[:len(slice)-1]

2. Буферизация данных

func readData(buf []byte) {
    temp := make([]byte, 1024)
    n, _ := reader.Read(temp)
    copy(buf, temp[:n]) // Безопасное копирование в ограниченный буфер
}

3. Копирование подмножеств данных

// Копирование части одного среза в часть другого
src := []int{1, 2, 3, 4, 5, 6, 7}
dst := make([]int, 10)
copy(dst[3:7], src[1:5])

Важные ограничения

1. Не работает с массивами напрямую — только через срезы:

   arr := [3]int{1, 2, 3}
   slice := make([]int, 3)
   copy(slice, arr[:]) // Нужно преобразовать массив в срез
   

2. Типы должны быть идентичными (кроме строки → байты/руны):

   var dst []int64
   var src []int // Ошибка компиляции: разные типы
   

3. Не изменяет ёмкость (capacity) целевого среза.

Производительность

На уровне компилятора Go функция copy оптимизируется в зависимости от:

• Размера типа элементов (специальные оптимизации для маленьких типов)
• Выравнивания данных в памяти
• Возможности использования векторных инструкций процессора

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

Заключение

Функция copy — это низкоуровневый инструмент для эффективного копирования данных в Go. Её основные преимущества:

• Предсказуемое поведение без скрытых аллокаций
• Безопасная работа с перекрывающимися областями памяти
• Высокая производительность за счёт компиляторных оптимизаций
• Универсальность благодаря поддержке работы со строками

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