Validador Regex de Email em Go

O que é Regex de Email em Go?

Em Go (Golang), o regex de email é usado para verificar se uma string é um endereço de email válido. Isso é comumente necessário para:

• Validação de campos de formulário durante o registro de usuários

• Verificações de entrada em APIs de backend

• Sanitização de entradas de usuário

• Fluxos de login e recuperação de conta

O pacote regexp do Go oferece tratamento de regex eficiente e de alta performance, facilitando a implementação dessas verificações com precisão e rapidez.

Por que Validar Emails em Go?

A validação de email é uma parte crítica de qualquer aplicação que lida com contas de usuário ou comunicação. Endereços de email inválidos podem levar a falhas em notificações, riscos de segurança e experiências ruins para o usuário. Seja construindo fluxos de autenticação, formulários de cadastro ou editores de perfil, uma validação robusta garante que apenas emails com formato correto entrem no seu sistema.

Abordagens Populares para Validação de Email em Go

Há várias formas de validar endereços de email em Go, cada uma com seus pontos fortes:

• Expressões Regulares (Regex): Ideal para verificar rapidamente se uma string de email corresponde a um padrão comum. O regex é altamente flexível e personalizável, tornando-se a escolha padrão para a maioria das validações de formulários e APIs.

• Pacotes Nativos: O Go oferece o pacote net/mail, que analisa endereços de email para conformidade com RFC. Este método é útil quando você precisa de validação mais rigorosa além da correspondência básica de padrões.

• Bibliotecas de Terceiros: Para validação ainda mais avançada, incluindo verificações de DNS ou detecção de emails descartáveis, pacotes externos podem ser aproveitados.

Validação de Email x Verificação de Email

Validação de email verifica se um endereço de email está formatado corretamente e livre de erros de digitação. Por exemplo, garante que "jane.doe@empresa.com" parece legítimo, enquanto detecta problemas óbvios como falta do símbolo "@" ou pontos duplos.

Verificação de email vai além. Confirma que o email é real e pertence ao usuário. Isso é feito normalmente enviando um link ou código de confirmação para o endereço, exigindo que o destinatário tome uma ação.

Exemplo de Padrão Regex de Email

Um regex compatível com Go comumente usado para validação de email:

^[a-zA-Z0-9._%%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Corresponde a:

• user@example.com

• john.doe_92@company.co

• test+1@domain.in

Não corresponde a:

• user@.com

• user@domain

• user@domain..com

Uma Forma Mais Simples: net/mail para Validação

Antes de se perder no regex, lembre-se de que a biblioteca padrão do Go inclui análise de email nativa com o pacote net/mail. Muitas vezes é mais seguro e mais compatível com RFC do que qualquer regex escrito à mão.

Uma verificação rápida em Go:

func valid(email string) bool {
    _, err := mail.ParseAddress(email)
    return err == nil
}

Atenção: O pacote segue a especificação RFC 5322 (e extensões), o que significa que endereços com domínio de uma letra são tecnicamente válidos, mesmo que esse domínio não seja público ou real. Este analisador verifica correção formal, não entregabilidade ou existência de domínio no mundo real.

Funcionalidades e Benefícios Principais

• Usa o motor regexp nativo do Go

• Captura grupos e destaca correspondências

• Feedback e validação em tempo real

• Ideal para formulários de login, cadastro ou perfil

• Funciona muito bem com emails simulados do Gerador de Email

Metacaracteres Úteis

• ^ : Início da string

• $ : Fim da string

• . : Qualquer caractere exceto nova linha

• + : Um ou mais

• * : Zero ou mais

• ? : Opcional

• [a-zA-Z0-9._%+-] : Conjunto de caracteres válidos para email

• @ : Símbolo arroba literal

• \\ : Usado para escapar caracteres em regex no Go

Exemplos de Regex de Email para Go

Exemplo 1: Validação Básica de Email

package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile(^[a-zA-Z0-9._%%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$)
email := "user@example.com"
fmt.Println("Is valid email:", pattern.MatchString(email))
}

Exemplo 2: Captura de Emails Inválidos

emails := []string{"bademail@", "user@@domain.com", "admin@site..com"}
for , e := range emails {
fmt.Println("Valid:", pattern.MatchString(e))
}

Exemplo 3: Correspondência sem Distinção de Maiúsculas

pattern := regexp.MustCompile((?i)^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$)

Validação de Email Personalizada com go-playground/validator

Às vezes a validação de email nativa não é suficiente. Com o popular pacote go-playground/validator, é fácil adicionar suas próprias regras.

1. Defina sua função personalizada

   func mustCompanyDomain(fl validator.FieldLevel) bool {
   return strings.HasSuffix(fl.Field().String(), "@mycompany.com")
   }

2. Registre no seu validador

   v := validator.New()
   v.RegisterValidation("companydomain", mustCompanyDomain)

3. Aplique a tag nas suas structs

   type Signup struct {
   Email string validate:"required,email,companydomain"
   }

4. Valide e verifique os erros

   applicant := Signup{Email: "tester@mycompany.com"}
   err := v.Struct(applicant)
   if err != nil {
   // Trate o email inválido
   }

Pacotes Externos para Validação de Email em Go

O pacote nativo regexp do Go cobre a maioria das necessidades de validação de email. Dois pacotes de terceiros merecem atenção:

go-playground/validator: Ideal para validar não apenas emails, mas campos de struct variados. Permite criar e registrar funções de validação personalizadas e fornece relatórios detalhados de erros por campo, sem necessidade de acesso à rede.

AfterShip/email-verifier: Vai além das verificações básicas, adicionando pesquisas de DNS/MX, verificações SMTP, detecção de emails descartáveis, identificação de provedores gratuitos e detecção de contas de função (como info@ ou support@).

Escolha o pacote que melhor atende aos requisitos do seu projeto: leve e local, ou robusto com verificações de rede.

Como Funciona a Verificação de Email em Go?

Enquanto a validação de email garante o formato correto, a verificação real de email confirma a propriedade real exigindo interação com a caixa de entrada.

1. Gere um token de verificação: Após o usuário enviar o email, o backend em Go cria um token único, geralmente um JWT, que codifica o email do usuário e um tempo de expiração.

2. Envie o email de verificação: O servidor envia um email com um link de verificação contendo o token como parâmetro de query.

3. Usuário clica no link: Seu servidor Go analisa o token, verifica sua validade e expiração, e extrai o email incorporado.

4. Ative a conta: Se o token for válido, o servidor marca o email do usuário como verificado.

Combine com Essas Ferramentas

• Gerador de Email – Obtenha emails aleatórios válidos para testar seu regex.

• Gerador de Senha – Teste fluxos de cadastro com email e senha.

• Gerador de Nome de Usuário – Adicione realismo a perfis de usuário simulados.

• Gerador de Endereço – Complete seus testes de formulário com dados de localização.

• Gerador de Chave de API – Para integrações baseadas em autenticação.

• Gerador de Número de Telefone – Adicione validação de telefone aos seus formulários.

Regex para Outras Linguagens

• JavaScript: Use no Testador de Regex JavaScript

• Java: Teste no Testador de Regex Java

• Python: Teste no Testador de Regex Python

Erros Comuns no Regex de Email

• Usar padrões excessivamente rígidos que bloqueiam emails válidos com + ou subdomínios.

• Esquecer de escapar o . no domínio.

• Não considerar TLDs com mais de 4 caracteres.

Não use: [a-zA-Z0-9.-]+@[a-z]+.[a-z]{2,3}, pois falha em muitos domínios válidos. Use nosso validador para testar casos extremos com segurança.