Как реализовать необязательные параметры функций в Go? Аналог перегрузки из других языков

Функциональные опции (Functional Options Pattern) — стандарт Go

В Go нет встроенной поддержки необязательных параметров или перегрузки, но сообщество выработало элегантный паттерн — Functional Options. Он широко используется в стандартной библиотеке (например, net/http.Server) и сторонних пакетах.

Основная идея:

• Создаём тип-функцию Option, которая принимает указатель на нашу структуру и модифицирует её поля.
• Пишем функции-конструкторы для каждой опции.
• Основная функция принимает вариативный список опций и применяет их.

Пример для вашей задачи с пользователем:

package main

import "fmt"

// User — структура с полями, которые мы хотим настраивать
type User struct {
    Name string
    Age  int
    City string
}

// Option — тип функции для установки опций
type Option func(*User)

// WithAge — функция-опция для установки возраста
func WithAge(age int) Option {
    return func(u *User) {
        u.Age = age
    }
}

// WithCity — функция-опция для установки города
func WithCity(city string) Option {
    return func(u *User) {
        u.City = city
    }
}

// NewUser — конструктор с обязательными и необязательными параметрами
func NewUser(name string, opts ...Option) *User {
    // Значения по умолчанию
    u := &User{
        Name: name,
        Age:  0,       // значение по умолчанию
        City: "Moscow", // значение по умолчанию
    }
    // Применяем все переданные опции
    for _, opt := range opts {
        opt(u)
    }
    return u
}

func main() {
    // Только обязательный параметр
    user1 := NewUser("Alice")
    fmt.Printf("%+v\n", user1) // &{Name:Alice Age:0 City:Moscow}

    // С возрастом
    user2 := NewUser("Bob", WithAge(25))
    fmt.Printf("%+v\n", user2) // &{Name:Bob Age:25 City:Moscow}

    // С возрастом и городом
    user3 := NewUser("Charlie", WithAge(30), WithCity("SPb"))
    fmt.Printf("%+v\n", user3) // &{Name:Charlie Age:30 City:SPb}

    // Только город
    user4 := NewUser("Diana", WithCity("Kazan"))
    fmt.Printf("%+v\n", user4) // &{Name:Diana Age:0 City:Kazan}
}

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

• Расширяемость — легко добавить новую опцию, не меняя сигнатуру функции.
• Читаемость — вызовы типа WithAge(25) самодокументируемы.
• Безопасность типов — все проверки на этапе компиляции.
• Совместимость с Go — не нарушает идиомы языка.

Альтернатива: структура конфигурации

Если параметров много (больше 4-5), можно передавать структуру:

type UserConfig struct {
    Age  int
    City string
}

func NewUserWithConfig(name string, cfg UserConfig) *User {
    if cfg.City == "" {
        cfg.City = "Moscow"
    }
    return &User{Name: name, Age: cfg.Age, City: cfg.City}
}

// Использование:
cfg := UserConfig{Age: 25, City: "SPb"}
user := NewUserWithConfig("Bob", cfg)

Но этот подход менее гибкий — нельзя передать только часть опций без явного создания структуры.

Важный нюанс

Если опциональный параметр может быть nil (например, указатель), используйте With* функции, которые принимают значение, а не указатель на него. Это сохраняет чистоту API.

Паттерн Functional Options — это де-факто стандарт в Go для эмуляции необязательных параметров. Он требует чуть больше boilerplate-кода, но окупается гибкостью и читаемостью.

func CreateUser(name string, args ...interface{}) {
    age := 0
    city := "Moscow"

    for i, arg := range args {
        switch i {
        case 0:
            if v, ok := arg.(int); ok {
                age = v
            }
        case 1:
            if v, ok := arg.(string); ok {
                city = v
            }
        }
    }

    fmt.Printf("Name: %s, Age: %d, City: %s\n", name, age, city)
}

// Использование:
CreateUser("Alice")                     // Name: Alice, Age: 0, City: Moscow
CreateUser("Bob", 25)                   // Name: Bob, Age: 25, City: Moscow
CreateUser("Charlie", 30, "SPb")        // Name: Charlie, Age: 30, City: SPb