Como passar um valor padrão para um método em Go: 5 soluções reais

Por que Go não tem parâmetros padrão (e isso é bom)

Imagine: você está programando em Go e quer criar um método com um parâmetro que pode ser omitido. Bem, como em Python: def greet(name="Convidado"). Você pega o teclado, escreve:

func (u *User) Greet(message string = "Olá") string {    return message + ", " + u.Name}

E então Go dá um erro. O compilador reclama, mas não deixa passar. Familiar? Esta pergunta (o original no Stack Overflow tem milhares de visualizações) atormenta cada segundo iniciante em Go. Os desenvolvedores da linguagem conscientemente recusaram valores padrão. Por quê? Porque Go é uma linguagem de explicitude. A legibilidade do código é mais importante que a brevidade. Mas isso não significa que você não possa simular um valor padrão em Go. Existem pelo menos 5 maneiras elegantes. Vamos analisar cada uma.

Método 1: Sobrecarga através de funções diferentes (Go-way)

A abordagem mais simples e "Go-ística" é simplesmente criar duas funções. Uma com parâmetro, outra sem.

type Config struct {    Timeout int}

func NewDefaultConfig() *Config {    return &Config{Timeout: 30} // valor padrão}

func NewConfig(timeout int) *Config {    if timeout <= 0 {        timeout = 30 // proteção contra tolos    }    return &Config{Timeout: timeout}}

Prós: Extremamente claro, lê-se em um segundo.
Contras: Com 3-4 parâmetros, resultará em uma explosão de funções.

Método 2: Struct com construtor (Builder Pattern)

Quando há muitos parâmetros (3+), o padrão Builder vem em socorro. Esta é uma expressão idiomática padrão em Go para trabalhar com parâmetros opcionais.

type Server struct {    Host    string    Port    int    Timeout time.Duration    MaxConn int}

// Valores padrãofunc NewServer() *Server {    return &Server{        Host:    "localhost",        Port:    8080,        Timeout: 30 * time.Second,        MaxConn: 100,    }}

// Métodos setters retornam o próprio objetofunc (s *Server) WithHost(host string) *Server {    s.Host = host    return s}

func (s *Server) WithPort(port int) *Server {    s.Port = port    return s}

// Usoserver := NewServer().    WithPort(9090).    WithTimeout(10 * time.Second)

Este padrão é ativamente usado na biblioteca padrão do Go (por exemplo, http.Server). Ele resolve o problema dos parâmetros padrão do Go sem gambiarras.

Método 3: Parâmetros variádicos (truque inesperado)

Você pode usar parâmetros variádicos (sinal ...). Esta é uma técnica não óbvia, mas funcional para um parâmetro opcional.

func Greet(name string, opts ...string) string {    greeting := "Olá" // valor padrão    if len(opts) > 0 {        greeting = opts[0]    }    return greeting + ", " + name}

// Usofmt.Println(Greet("João"))           // "Olá, João"fmt.Println(Greet("Maria", "Bom dia")) // "Bom dia, Maria"

Funciona, mas parece uma gambiarra. Use apenas se precisar de uma solução rápida.

Método 4: Opções Funcionais (o mais Go-ístico)

Esta é a técnica consagrada dos desenvolvedores Go. Foi popularizada pela primeira vez por Dave Cheney. Permite definir valor padrão em Go para qualquer número de parâmetros.

type Option func(*Client)

type Client struct {    URL     string    Timeout time.Duration    Retries int}

// Valores padrãofunc defaultClient() *Client {    return &Client{        URL:     "https://api.example.com",        Timeout: 10 * time.Second,        Retries: 3,    }}

// Opçõesfunc WithURL(url string) Option {    return func(c *Client) {        c.URL = url    }}

func WithTimeout(t time.Duration) Option {    return func(c *Client) {