Go Academy · Aula

Padrões de construtores

Crie construtores idiomáticos em Go

Padrões de construtores é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Por que usar construtores?

Go não tem uma palavra-chave new para tipos nem construtores de classes. A convenção é usar uma função chamada New... que valide as entradas e retorne um valor ou ponteiro inicializado.

Função New simples

Retorne um ponteiro para garantir que o chamador trabalhe com uma instância compartilhada:

package main
import "fmt"

type Server struct {
    Host string
    Port int
}

func NewServer(host string, port int) *Server {
    return &Server{Host: host, Port: port}
}

func main() {
    s := NewServer("localhost", 8080)
    fmt.Println(s.Host, s.Port)
}

Validação em construtores

Os construtores são um bom lugar para validar entradas e retornar um erro:

package main
import ("errors"; "fmt")

type Config struct{ Workers int }

func NewConfig(workers int) (*Config, error) {
    if workers < 1 {
        return nil, errors.New("workers must be >= 1")
    }
    return &Config{Workers: workers}, nil
}

func main() {
    c, err := NewConfig(4)
    fmt.Println(c, err)
}

Padrão de opções funcionais

O padrão de opções funcionais permite uma configuração opcional sem quebrar a API:

package main
import "fmt"

type Server struct{ host string; port int; timeout int }
type Option func(*Server)

func WithPort(p int) Option    { return func(s *Server) { s.port = p } }
func WithTimeout(t int) Option { return func(s *Server) { s.timeout = t } }

func NewServer(host string, opts ...Option) *Server {
    s := &Server{host: host, port: 8080, timeout: 30}
    for _, o := range opts { o(s) }
    return s
}

func main() {
    s := NewServer("localhost", WithPort(9090), WithTimeout(60))
    fmt.Println(s.port, s.timeout)
}

Padrão de construção

Para objetos complexos, o padrão de construção encadeia métodos configuradores e retorna o resultado:

package main
import "fmt"

type QueryBuilder struct{ table, where string; limit int }

func (q *QueryBuilder) Table(t string) *QueryBuilder { q.table = t; return q }
func (q *QueryBuilder) Where(w string) *QueryBuilder { q.where = w; return q }
func (q *QueryBuilder) Limit(n int)   *QueryBuilder { q.limit = n; return q }
func (q *QueryBuilder) Build() string {
    return fmt.Sprintf("SELECT * FROM %s WHERE %s LIMIT %d", q.table, q.where, q.limit)
}

func main() {
    sql := (&QueryBuilder{}).Table("users").Where("age>18").Limit(10).Build()
    fmt.Println(sql)
}

Retornando valor ou ponteiro

Retorne um valor quando a estrutura for pequena e imutável; retorne um ponteiro quando a estrutura for grande, mutável ou implementar interfaces:

Estruturas pequenas de configuração → valor
Objetos com estado (servidor, cliente, conjunto) → ponteiro
Se estiver implementando uma interface com receptores por ponteiro → ponteiro

Padrão de valores padrão

Use uma função de valores padrão ou um literal de estrutura para definir valores padrão adequados antes de aplicar as opções:

package main
import "fmt"

type Cache struct{ maxSize int; ttlSecs int }

func defaultCache() Cache { return Cache{maxSize: 100, ttlSecs: 300} }

func NewCache(opts ...func(*Cache)) *Cache {
    c := defaultCache()
    for _, o := range opts { o(&c) }
    return &c
}

func main() {
    c := NewCache(func(c *Cache) { c.maxSize = 500 })
    fmt.Println(c.maxSize, c.ttlSecs) // 500 300
}

Padrão de instância única

Use sync.Once para inicializar um recurso compartilhado exatamente uma vez:

package main
import ("fmt"; "sync")

type DB struct{ DSN string }

var (
    instance *DB
    once     sync.Once
)

func GetDB(dsn string) *DB {
    once.Do(func() { instance = &DB{DSN: dsn} })
    return instance
}

func main() {
    db1 := GetDB("postgres://...")
    db2 := GetDB("ignored")
    fmt.Println(db1 == db2) // true
}

Testando construtores

Construtores que retornam erros são fáceis de testar:

package main
import ("errors"; "fmt")

type Pool struct{ size int }

func NewPool(size int) (*Pool, error) {
    if size <= 0 { return nil, errors.New("size must be positive") }
    return &Pool{size: size}, nil
}

func main() {
    _, err := NewPool(-1)
    fmt.Println(err) // size must be positive
    p, _ := NewPool(5)
    fmt.Println(p.size) // 5
}

Evite a inicialização automática

As funções init() são executadas automaticamente e são difíceis de testar. Prefira construtores explícitos que retornem erros à inicialização implícita em init().

Verificação rápida

O que o padrão de opções funcionais proporciona?

Recapitulação: padrões de construtores

Principais aprendizados:

Use funções New... como construtores
Retorne erros para falhas de validação
Use opções funcionais para configurações opcionais flexíveis
Use o padrão de construção para objetos complexos de consulta ou configuração
Prefira construtores explícitos a init()

Exercício prático

Implemente um construtor NewHTTPClient usando opções funcionais. Dê suporte às opções WithTimeout, WithBaseURL e WithMaxRetries.

Perguntas Frequentes

A aula “Padrões de construtores” é grátis?

Sim — o texto completo de “Padrões de construtores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Padrões de construtores”?

Crie construtores idiomáticos em Go Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Padrões de construtores”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy