Padrões e validação
Defina padrões sensatos
Padrões e validação é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 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.
Defina padrões sensatos
Um construtor robusto começa com bons padrões e depois permite que as opções os substituam. Isso evita completamente a armadilha do valor zero.
Inicialize antes de aplicar
Crie a configuração com os padrões primeiro e depois aplique as opções sobre ela.
package main
import "fmt"
type Server struct {
Port int
Timeout int
}
type Option func(*Server)
func WithPort(p int) Option { return func(s *Server) { s.Port = p } }
func NewServer(opts ...Option) *Server {
s := &Server{Port: 8080, Timeout: 30}
for _, o := range opts { o(s) }
return s
}
func main() {
fmt.Printf("%+v\n", *NewServer())
fmt.Printf("%+v\n", *NewServer(WithPort(9000)))
}Os padrões vencem até serem substituídos
Uma chamada sem opções produz os padrões; uma opção substitui apenas o campo que altera. O melhor dos dois mundos.
Validando após a aplicação
Depois de aplicar as opções, valide a configuração final e retorne um erro se ela for inválida. Faça o construtor retornar (*T, error).
package main
import (
"errors"
"fmt"
)
type Server struct{ Port int }
type Option func(*Server)
func WithPort(p int) Option { return func(s *Server) { s.Port = p } }
func NewServer(opts ...Option) (*Server, error) {
s := &Server{Port: 8080}
for _, o := range opts { o(s) }
if s.Port < 1 || s.Port > 65535 {
return nil, errors.New("invalid port")
}
return s, nil
}
func main() {
_, err := NewServer(WithPort(99999))
fmt.Println(err)
}Validação dentro das opções
Como alternativa, as próprias opções podem retornar um erro. O tipo Option passa a ser func(*Config) error.
package main
import (
"errors"
"fmt"
)
type Server struct{ Port int }
type Option func(*Server) error
func WithPort(p int) Option {
return func(s *Server) error {
if p < 1 {
return errors.New("port must be positive")
}
s.Port = p
return nil
}
}
func NewServer(opts ...Option) (*Server, error) {
s := &Server{Port: 8080}
for _, o := range opts {
if err := o(s); err != nil {
return nil, err
}
}
return s, nil
}
func main() {
_, err := NewServer(WithPort(-1))
fmt.Println(err)
}Qual estilo de validação escolher
Valide nas opções para verificações específicas de cada configuração; valide depois da aplicação para regras entre campos, como o fato de o TLS exigir um caminho para o certificado. Muitas vezes, você usará os dois estilos.
Documentando os padrões
Sempre documente cada padrão no comentário de documentação do construtor para que os usuários saibam o que receberão quando omitirem uma opção.
Obrigatório versus opcional
Mantenha os valores realmente obrigatórios como parâmetros posicionais; reserve as opções para o que for verdadeiramente opcional. Não esconda dados obrigatórios atrás de uma opção.
package main
import "fmt"
type Client struct {
BaseURL string
Retries int
}
type Option func(*Client)
func WithRetries(n int) Option { return func(c *Client) { c.Retries = n } }
func NewClient(baseURL string, opts ...Option) *Client {
c := &Client{BaseURL: baseURL, Retries: 3}
for _, o := range opts { o(c) }
return c
}
func main() {
fmt.Printf("%+v\n", *NewClient("https://api"))
}Combinando opções
Você pode compor várias opções em uma única predefinição para configurações comuns.
package main
import "fmt"
type Server struct{ Port, 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 Production() Option {
return func(s *Server) {
WithPort(443)(s)
WithTimeout(60)(s)
}
}
func NewServer(opts ...Option) *Server {
s := &Server{Port: 8080, Timeout: 30}
for _, o := range opts { o(s) }
return s
}
func main() {
fmt.Printf("%+v\n", *NewServer(Production()))
}Práticas recomendadas
- Comece com os padrões e depois aplique as opções
- Valide depois da aplicação para regras entre campos
- Mantenha os valores obrigatórios posicionais
- Documente todos os padrões
Uma API completa e robusta
Combinar padrões, opções e validação proporciona um construtor flexível, seguro, autoexplicativo e fácil de ampliar.
Verificação rápida
Teste seus conhecimentos sobre padrões e validação.
Recapitulação
Você concluiu o padrão de opções funcionais.
- Defina os padrões antes de aplicar as opções
- Valide depois da aplicação ou dentro das opções para verificações por campo
- Mantenha os valores obrigatórios posicionais
- Componha opções em predefinições e documente os padrões
Perguntas Frequentes
A aula “Padrões e validação” é grátis?
Sim — o texto completo de “Padrões e validação” é 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 e validação”?
Defina padrões sensatos 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 4 de 4.
Quanto tempo leva a aula “Padrões e validação”?
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.