Noções Básicas de Funções e Métodos

10 exemplos para você começar com Funções e Interfaces - 7 básicos e 3 intermediários.

Pré-requisitos

• Go 1.26.x instalado (go version).
• Nenhum módulo de terceiros é necessário - os trechos usam apenas a biblioteca padrão.

Exemplos Básicos

1. Função Nomeada com Múltiplos Retornos

Funções Go retornam valores explícitos, frequentemente um resultado mais error.

package main
 
import (
    "fmt"
    "strconv"
)
 
func parsePort(s string) (int, error) {
    return strconv.Atoi(s)
}
 
func main() {
    port, err := parsePort("8080")
    if err != nil {
        fmt.Println("parse:", err)
        return
    }
    fmt.Println("listening on", port)
}

• Múltiplos valores de retorno substituem parâmetros de saída e canais de exceção.
• Chamadores devem tratar error no local da chamada - o fluxo de controle permanece visível.
• Valores zero se aplicam quando você ignora um retorno com _.

Relacionado: Múltiplos Retornos, Retornos Nomeados e Retornos Nus - quando nomear resultados

2. Método com Receptor de Valor

Métodos anexam comportamento a tipos; receptores de valor operam em uma cópia.

package main
 
import "fmt"
 
type Counter struct {
    n int
}
 
func (c Counter) Value() int {
    return c.n
}
 
func main() {
    c := Counter{n: 3}
    fmt.Println(c.Value())
}

• O receptor (c Counter) copia a struct para o corpo do método.
• Acessadores somente leitura frequentemente usam receptores de valor para evitar mutação acidental.
• Métodos são apenas funções com um parâmetro receptor.

Relacionado: Métodos: Receptores de Valor vs. Ponteiro - escolhendo o tipo de receptor

3. Método com Receptor de Ponteiro

Receptores de ponteiro mutam o valor original e correspondem a structs maiores de forma eficiente.

package main
 
import "fmt"
 
type Counter struct {
    n int
}
 
func (c *Counter) Inc() {
    c.n++
}
 
func main() {
    c := &Counter{}
    c.Inc()
    c.Inc()
    fmt.Println(c.n)
}

• (c *Counter) permite que Inc modifique o estado do chamador.
• Go automaticamente pega o endereço ao chamar c.Inc() em uma variável de valor.
• Consistência é importante: misturar tipos de receptores em um tipo confunde a satisfação de interface.

4. Interface do Lado do Consumidor

Interfaces são satisfeitas implicitamente quando os métodos correspondem.

package main
 
import "fmt"
 
type Stringer interface {
    String() string
}
 
type User struct {
    Name string
}
 
func (u User) String() string {
    return "user:" + u.Name
}
 
func printLabel(s Stringer) {
    fmt.Println(s.String())
}
 
func main() {
    printLabel(User{Name: "ada"})
}

• User nunca menciona Stringer - o compilador verifica na atribuição.
• Defina interfaces onde elas são consumidas para manter dependências estreitas.
• Interfaces pequenas tornam os duplos de teste triviais.

Relacionado: Definindo e Implementando Interfaces - padrões de design de API

5. Tipo de Função e Valor

Funções são valores de primeira classe com seus próprios tipos nomeados.

package main
 
import "fmt"
 
type Op func(int, int) int
 
func apply(a, b int, op Op) int {
    return op(a, b)
}
 
func main() {
    add := func(x, y int) int { return x + y }
    fmt.Println(apply(2, 3, add))
}

• type Op func(...) documenta a intenção melhor do que repetir func(int,int) int.
• Valores de função podem capturar variáveis (closures) - veja exemplos intermediários.
• Funções de ordem superior substituem alguma cerimônia de interface para hooks únicos.

Relacionado: Funções Variádicas e Tipos de Função - padrões variádicos e HOF

6. Parâmetro Variádico

O último parâmetro pode absorver uma lista variável de argumentos.

package main
 
import "fmt"
 
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
 
func main() {
    fmt.Println(sum(1, 2, 3, 4))
}

• nums ...int é um slice dentro da função ([]int).
• Chamadores podem passar zero ou muitos argumentos; você também pode espalhar um slice com sum(vals...).
• Variádico deve ser o último parâmetro na assinatura.

7. Parâmetros de Resultado Nomeados

Nomes de resultado agem como variáveis no corpo da função e aparecem na documentação.

package main
 
import "fmt"
 
func divide(a, b float64) (quot float64, ok bool) {
    if b == 0 {
        return 0, false
    }
    quot = a / b
    ok = true
    return
}
 
func main() {
    q, ok := divide(10, 2)
    fmt.Println(q, ok)
}

• Resultados nomeados são inicializados com valores zero na entrada da função.
• return nu retorna os valores nomeados atuais - use com moderação para clareza.
• Útil em funções curtas com muitos defer; prejudicial quando obscurecem a lógica.

Relacionado: Múltiplos Retornos, Retornos Nomeados e Retornos Nus - trade-offs de retornos nus

Exemplos Intermediários

8. Captura de Variável de Loop por Closure (Padrão Seguro)

Closures capturam variáveis por referência; iteradores de loop precisam de uma cópia local por iteração.

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        i := i
        wg.Add(1)
        go func() {
            defer wg.Done()
            fmt.Println(i)
        }()
    }
    wg.Wait()
}

• Sem i := i, goroutines podem observar o valor final do loop.
• defer wg.Done() emparelha com Add para desligamento limpo de trabalho concorrente.
• Prefira passar variáveis de loop como parâmetros de função quando o closure for reutilizado.

Relacionado: Literais de Função e Closures - padrões de fábrica e middleware

9. Aceitar Interface, Retornar Struct

Conecte dependências através de interfaces pequenas; construtores retornam tipos concretos.

package main
 
import (
    "context"
    "fmt"
)
 
type Notifier interface {
    Notify(ctx context.Context, msg string) error
}
 
type Logger struct{}
 
func (Logger) Notify(ctx context.Context, msg string) error {
    fmt.Println("notify:", msg)
    return nil
}
 
type Service struct {
    n Notifier
}
 
func NewService(n Notifier) *Service {
    return &Service{n: n}
}
 
func (s *Service) Run(ctx context.Context) error {
    return s.n.Notify(ctx, "ready")
}
 
func main() {
    svc := NewService(Logger{})
    _ = svc.Run(context.Background())
}

• NewService aceita Notifier para testes; retorna *Service como API concreta.
• Passe context.Context como o primeiro parâmetro em limites de I/O.
• Mantém pacotes compostos sem herança ou frameworks de DI.

Relacionado: Funções e Interfaces: Modelo de Composição de Go - modelo mental para composição

10. Nil de Tipo em uma Variável de Interface

Um ponteiro nil armazenado em uma interface não é igual a uma interface nil sem tipo.

package main
 
import "fmt"
 
type Worker interface {
    Work() error
}
 
type job struct{}
 
func (j *job) Work() error { return nil }
 
func main() {
    var w Worker = (*job)(nil)
    fmt.Println(w == nil)
}

• w contém o tipo *job com valor nil - a própria interface não é nil.
• if w == nil falha mesmo que nenhuma instância concreta exista.
• Retorne interfaces apenas quando necessário; documente explicitamente "nil significa ausente".

Relacionado: Interface Nil vs. Ponteiro Nil - designs de API que evitam a armadilha

Versões da Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).