Как передаются параметры в методы в Go?

Передача параметров в методы Go: значение vs указатель

В языке Go параметры в методы всегда передаются по значению (by value), однако это утверждение требует важных уточнений, когда речь идет о указателях (pointers), срезах (slices) и картах (maps). Давайте подробно разберем все аспекты.

Основной механизм: передача по значению

Когда вы передаете параметр в метод в Go, создается копия этого значения в памяти стека вызова функции. Это означает, что любые изменения, сделанные внутри метода, не затрагивают оригинальную переменную.

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

// Метод с получателем по значению
func (p Person) SetAgeByValue(newAge int) {
    p.Age = newAge // Изменяется только копия
}

func main() {
    person := Person{Name: "Alice", Age: 25}
    person.SetAgeByValue(30)
    fmt.Println(person.Age) // Вывод: 25 (оригинал не изменился)
}

Передача по указателю

Чтобы изменять оригинальную структуру, необходимо использовать указатель в качестве получателя (receiver):

// Метод с получателем-указателем
func (p *Person) SetAgeByPointer(newAge int) {
    p.Age = newAge // Изменяется оригинальная структура
}

func main() {
    person := Person{Name: "Bob", Age: 25}
    person.SetAgeByPointer(30)
    fmt.Println(person.Age) // Вывод: 30 (оригинал изменен)
    
    // Альтернативный вызов
    (&person).SetAgeByPointer(35) // Явное взятие адреса
}

Важное упрощение: Go автоматически преобразует person.SetAgeByPointer() в (&person).SetAgeByPointer(), когда метод имеет получатель-указатель.

Особенности передачи срезов, карт и каналов

Это наиболее тонкий аспект передачи параметров:

package main

import "fmt"

func modifySlice(s []int) {
    s[0] = 100 // Изменение отразится на оригинале!
    s = append(s, 999) // Это не изменит оригинальный срез
}

func main() {
    slice := []int{1, 2, 3}
    modifySlice(slice)
    fmt.Println(slice) // Вывод: [100 2 3]
}

Почему так происходит:

• Срез — это дескриптор, содержащий указатель на массив, длину и емкость
• При передаче среза копируется этот дескриптор, но не копируется underlying array
• Аналогичное поведение у карт (maps) и каналов (channels) — передается копия дескриптора

Практические рекомендации по выбору типа получателя

Используйте получатель-указатель, когда:

1. Метод должен модифицировать получатель
2. Структура содержит большие объемы данных (избегаем дорогого копирования)
3. Структура содержит поля, которые не копируются (каналы, мьютексы)

Используйте получатель по значению, когда:

1. Метод не должен изменять получатель (идиоматично для "геттеров")
2. Структура небольшая (обычно до 64-128 байт)
3. Требуется иммутабельность данных
4. Работаете с базовыми типами (int, string, bool)

Сравнение производительности

type SmallStruct struct {
    a, b int64
}

type BigStruct struct {
    data [1e6]float64 // 8 МБ данных
}

// Эффективно: копируется только 16 байт
func (s SmallStruct) ValueMethod() int64 {
    return s.a + s.b
}

// Неэффективно: копируется 8 МБ!
func (b BigStruct) InefficientMethod() float64 {
    return b.data[0]
}

// Оптимально: копируется только указатель (8 байт)
func (b *BigStruct) EfficientMethod() float64 {
    return b.data[0]
}

Идиоматические паттерны Go

1. Консистентность в наборе методов: если хотя бы один метод структуры использует получатель-указатель, все методы, которые работают с той же структурой, обычно также используют указатель.

2. Nil-безопасность методов с указателями:

func (p *Person) GetName() string {
    if p == nil {
        return "Unknown"
    }
    return p.Name
}

1. Методы для встроенных типов (нельзя определять методы для указателей на встроенные типы):

type MyInt int

func (m MyInt) Double() MyInt { // Только по значению!
    return m * 2
}

Критические отличия от других языков

• Нет передачи по ссылке (как в C# или PHP) — только по значению или через указатели
• Нет неявного боксинга/анбоксинга (в отличие от C#)
• Автоматическое разыменование при вызове методов (person.Method() работает и для *Person)
• Семантика "всегда копирование" делает поведение предсказуемым

Заключение

Понимание передачи параметров в Go — ключ к написанию эффективного и корректного кода. Запомните:

• Базовые типы, структуры, массивы передаются полной копией
• Указатели передаются как копия адреса (8 байт на 64-битных системах)
• Слайсы, карты, каналы, функции, интерфейсы передаются как копия дескриптора
• Выбор между значением и указателем — компромисс между безопасностью и производительностью
• Консистентность важна — смешивание стимов в методах одной структуры считается антипаттерном

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