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

Проблема: почему просто проверка на ноль не работает

Вы правы — проверка на нулевое значение (ноль, пустая строка, nil) не является надёжным способом, потому что пользователь может явно передать такое значение. В Go нет перегрузки функций и нет именованных аргументов с дефолтами, как в Python. Но есть несколько идиоматических паттернов, которые решают эту задачу.

Решение 1: вариативные функции (variadic functions)

Самый простой способ — сделать необязательные параметры вариативными. Недостаток: можно передать только одно значение и порядок фиксирован.

package main

import "fmt"

type Config struct {
    Address string
    Timeout int
}

func NewClient(address string, timeout ...int) *Config {
    t := 30 // значение по умолчанию
    if len(timeout) > 0 {
        t = timeout[0]
    }
    return &Config{Address: address, Timeout: t}
}

func main() {
    client1 := NewClient("localhost:8080")
    fmt.Printf("%+v\n", client1) // Address:localhost:8080 Timeout:30

    client2 := NewClient("localhost:8080", 10)
    fmt.Printf("%+v\n", client2) // Address:localhost:8080 Timeout:10
}

Решение 2: паттерн "Functional Options" (рекомендуемый)

Это самый идиоматический способ в Go. Вы создаёте тип-функцию Option, которая модифицирует структуру, и передаёте её в конструктор.

package main

import (
    "fmt"
    "time"
)

type Config struct {
    Address string
    Timeout time.Duration
}

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

// WithTimeout задаёт таймаут
func WithTimeout(t time.Duration) Option {
    return func(c *Config) {
        c.Timeout = t
    }
}

// NewClient — конструктор с опциями
func NewClient(address string, opts ...Option) *Config {
    // Значения по умолчанию
    cfg := &Config{
        Address: address,
        Timeout: 30 * time.Second,
    }
    // Применяем все опции
    for _, opt := range opts {
        opt(cfg)
    }
    return cfg
}

func main() {
    // Без опций — используется таймаут по умолчанию
    client1 := NewClient("localhost:8080")
    fmt.Printf("%+v\n", client1) // Address:localhost:8080 Timeout:30s

    // С опцией — переопределяем таймаут
    client2 := NewClient("localhost:8080", WithTimeout(10*time.Second))
    fmt.Printf("%+v\n", client2) // Address:localhost:8080 Timeout:10s

    // Можно передать несколько опций (если добавить)
}

Преимущества паттерна:

• Расширяемость: легко добавлять новые опции без изменения сигнатуры.
• Читаемость: вызов выглядит как именованные аргументы.
• Безопасность: порядок опций не важен.

Решение 3: структура с конфигурацией

Если параметров много, можно вынести их в отдельную структуру и передавать её в конструктор.

type Config struct {
    Address string
    Timeout int
}

type ClientOptions struct {
    Timeout int
}

func NewClient(address string, opts *ClientOptions) *Config {
    t := 30
    if opts != nil && opts.Timeout != 0 {
        t = opts.Timeout
    }
    return &Config{Address: address, Timeout: t}
}

func main() {
    client1 := NewClient("localhost:8080", nil)
    client2 := NewClient("localhost:8080", &ClientOptions{Timeout: 10})
}

Рекомендация

Для большинства случаев используйте паттерн "Functional Options". Он считается наиболее идиоматичным в сообществе Go (см. стандартные библиотеки, например, net/http с Server). Если опций всего 1–2 и они простые, можно обойтись вариативными аргументами.

func NewClient(address string, timeout *int) *Config {
    t := 30 // значение по умолчанию
    if timeout != nil {
        t = *timeout
    }
    return &Config{Address: address, Timeout: t}
}

// Использование:
client1 := NewClient("localhost:8080", nil)          // таймаут = 30
t := 0
client2 := NewClient("localhost:8080", &t)          // таймаут = 0 (явно)