Validador Regex de Data em Go

Valide datas nos formatos YYYY-MM-DD, DD/MM/YYYY ou MM-DD-YYYY com este Validador Regex de Data em Go. Ideal para entradas de formulários, logs e relatórios. Teste seus padrões com o Go Regex Tester e combine com ferramentas como Regex de Email, Regex de Número e Validador de Senha para uma suite completa de validação de dados.

Validador Regex de Data em Go - Documentação

Introdução: O que é Regex de Data?

Validar strings de data é essencial quando você trabalha com logs, formulários de usuário, relatórios ou qualquer entrada estruturada na sua aplicação Go. Usar regex para validar datas garante que os usuários insiram dados no formato correto antes de serem salvos ou processados.

Em Go, a validação com regex funciona bem para verificações básicas de formato, como:

YYYY-MM-DD (formato ISO)
DD/MM/YYYY (comum no Brasil e na Europa)
MM-DD-YYYY (comum nos EUA)

Mas, ao lidar com dados reais, os formatos de data podem ser bastante variados. Além de barras e hífens, você encontrará datas separadas por pontos (ex.: 12.31.2024), escritas sem zeros à esquerda (1/2/2024 em vez de 01/02/2024), ou até com anos de dois dígitos (12/31/24). Essas variações são especialmente comuns quando usuários copiam e colam de diferentes fontes, ou quando os dados vêm de sistemas internacionais.

Para criar um padrão regex realmente robusto, é importante considerar essas peculiaridades e preferências regionais. Seu padrão deve ser flexível o suficiente para lidar com hífens, barras, pontos, dias e meses com um único dígito, e anos de dois ou quatro dígitos. Essa atenção extra garante que sua validação de datas seja precisa e fácil de usar, independentemente da origem dos dados.

Blocos de Construção do Regex

Para validar datas (ou qualquer string) com regex, é útil conhecer os elementos fundamentais:

A-Z : letras maiúsculas
a-z : letras minúsculas
0-9 : dígitos
\. : um ponto literal
+ : um ou mais do elemento anterior
* : zero ou mais do elemento anterior
? : opcional (zero ou um)
^ : início da string
$ : fim da string

Uma expressão regular é essencialmente um padrão de busca construído a partir desses elementos. Metacaracteres como ^ e $ ancoram a correspondência ao início ou ao fim de uma string, enquanto quantificadores como + e {n} definem quantas vezes um caractere ou grupo deve aparecer. Regex vai muito além de encontrar padrões básicos: você pode usá-lo para validar formatos como MM/DD/YYYY, extrair dados de logs ou combinar apenas quando certas condições forem atendidas.

Padrões Regex de Data

Formato ISO (YYYY-MM-DD)

^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$

Aceita: 2024-12-31
Rejeita: 2024-13-01, 2024-02-30

Este é o formato padrão usado na maioria das APIs e bancos de dados. Garante que o ano tenha quatro dígitos, o mês varie de 01 a 12, e o dia seja válido para o mês.

Formato DD/MM/YYYY

^(0[1-9]|[12]\d|3[01])/(0[1-9]|1[0-2])/\d{4}$

Aceita: 31/12/2024
Rejeita: 00/00/2024, 32/01/2024

Este formato é comum no Brasil e em grande parte da Europa. O padrão verifica zeros à esquerda e usa barra como separador.

Formato MM-DD-YYYY

^(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])-\d{4}$

Aceita: 12-31-2024
Rejeita: 13-01-2024, 00-15-2022

Amplamente utilizado nos Estados Unidos, este formato usa hífen como separador e espera dois dígitos para mês e dia.

Construindo um Regex para Datas MM/DD/YYYY

Criar um regex para validar datas no formato MM/DD/YYYY exige cuidado. Veja o processo passo a passo:

Mês com dois dígitos: Comece com (0[1-9]|1[0-2]) para garantir que o mês esteja entre 01 e 12.
Separador: Use barra ou hífen, incluindo [/-].
Dia com dois dígitos: (0[1-9]|[12]\d|3[01]) cobre de 01 a 31.
Outro separador: Novamente [/-].
Ano com quatro dígitos: Use \d{4}.

O padrão completo:

^(0[1-9]|1[0-2])[/-](0[1-9]|[12]\d|3[01])[/-]\d{4}$

Aceita: 12/31/2024, 01-01-2023
Rejeita: 00/10/2024, 13/28/2024, 11-31-2024

O que é o Formato MM/DD/YYYY?

O formato MM/DD/YYYY estrutura datas com mês de dois dígitos, barra, dia de dois dígitos, outra barra e ano de quatro dígitos. Por exemplo, 12/31/2024 significa 31 de dezembro de 2024.

Esse estilo é comum nos Estados Unidos. O separador usual é a barra, mas você pode encontrar hífens ou pontos em outros contextos. Não confunda com DD/MM/YYYY, que é padrão em muitos outros países, incluindo o Brasil.

Variações Comuns

Datas aparecem em muitos formatos. Às vezes os separadores variam: hífens (-), barras (/) ou pontos (.). Alguns sistemas aceitam datas sem zeros à esquerda (ex.: 7/5/24) ou com anos de dois dígitos (05/12/99). Para acomodar essas variações, considere padrões como:

^\d{1,2}[/.-]\d{1,2}[/.-]\d{2,4}$

Aceita dias e meses com um ou dois dígitos
Aceita /, - ou . como separadores
Aceita anos de dois ou quatro dígitos

Variantes de Exemplo

^\d{4}-\d{2}-\d{2}$ - Formato estrito YYYY-MM-DD (ex.: 2025-07-15)
^\d{2}/\d{2}/\d{4}$ - Formato MM/DD/YYYY (ex.: 07/15/2025)
^\d{1,2}[/.-]\d{1,2}[/.-]\d{2,4}$ - Formato flexível com dia/mês de 1 a 2 dígitos e ano de 2 a 4 dígitos

Se quiser flexibilidade com separadores, use uma classe de caracteres como [/.-] onde o separador aparece. Atenção: padrões mais flexíveis aumentam a chance de aceitar datas inválidas como 99/99/9999, portanto valide também na lógica da aplicação.

Como Validar Datas com Regex em Go

Veja um programa Go que verifica se uma string de data está no formato ISO correto (YYYY-MM-DD):

package main
import (
"fmt"
"regexp"
)
func isValidDate(date string) bool {
// Regex for YYYY-MM-DD
pattern := ^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$
regex := regexp.MustCompile(pattern)
return regex.MatchString(date)
}
func main() {
dates := []string{"2025-01-30", "2025-13-01", "2024-02-30"}
for _, date := range dates {
fmt.Printf("Is '%s' valid? %t\n", date, isValidDate(date))
}
}

Casos de Uso da Validação de Data com Regex

Validação de Formulários: Verifique se os usuários inseriram data de nascimento ou compromisso no formato correto.
Limpeza de Dados: Identifique e remova datas malformadas em grandes conjuntos CSV ou JSON.
Segurança: Previna injeção de datas ou exploits de strings malformadas em APIs e formulários.
Filtragem de Logs: Analise entradas de log que contêm strings de data.

Dicas Profissionais

Use regex para validação de formato, mas ainda verifique se a data realmente existe (ex.: 30 de fevereiro não é válido).
Para formatos com hora, estenda o regex (ex.: ^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$ para timestamps).
Teste o regex usando o Go Regex Tester antes de aplicar em produção.
Para validação e limpeza em massa, combine com ferramentas como CSV Cleaner ou JSON Validator (em breve).

Dicas de Eficiência para Regex

Evite intervalos de classes de caracteres desnecessários - mantenha seus padrões enxutos.
Use grupos não capturadores quando os parênteses servem apenas para agrupamento, não para captura.
Considere quantificadores possessivos ou grupos atômicos quando quiser evitar retrocesso desnecessário no motor de regex.

Armadilhas Comuns a Evitar

O regex captura muito, mas não é mágico. Veja algumas armadilhas clássicas:

Esquecer de exigir zeros à esquerda em meses ou dias.
Não limitar o intervalo de meses e dias, permitindo valores como 99.
Ignorar que regex não captura datas impossíveis: 30 de fevereiro passa pela validação de formato, a menos que você adicione uma verificação extra.

Implementando Validação de Data em Outras Linguagens

Independentemente do stack, a validação de datas com regex é direta em qualquer linguagem:

JavaScript: Use o método .test() do objeto RegExp:

const datePattern = /^\d{4}-\d{2}-\d{2}$/;
const isValid = datePattern.test("2024-01-28");

Python: Use o módulo re com re.match() ou re.fullmatch():

import re
pattern = r"\d{2}/\d{2}/\d{4}"
is_valid = re.fullmatch(pattern, "28/01/2024") is not None

Go: Use regexp.MatchString() para verificações rápidas:

import "regexp"
matched, _ := regexp.MatchString(^\d{2}-\d{2}-\d{4}$, "28-01-2024")

Java: Use Pattern e Matcher:

Pattern pattern = Pattern.compile("\d{2}/\d{2}/\d{4}");
Matcher matcher = pattern.matcher("28/01/2024");
boolean isValid = matcher.matches();

Armadilhas Comuns ao Otimizar Regex de Data

Padrões Excessivamente Complexos: Tentar cobrir todos os casos extremos pode transformar seu regex em código ilegível. Foque nas verificações de formato essenciais e use lógica adicional em Go para validações mais profundas.
Muito Rígido ou Muito Permissivo: Equilibre entre capturar erros comuns e permitir formatos legítimos.
Descuidar da Performance: Antes de colocar seu regex em produção, teste-o, especialmente em entradas grandes. Alguns padrões podem causar lentidão ou "backtracking catastrófico".

Dica: Use ferramentas como Regex101 ou o Go Regex Tester para visualizar correspondências e comparar seus padrões.

Otimizando Regex para Performance e Legibilidade

Simplifique sempre que possível: Fique com o padrão mais curto que resolve o problema.
Prefira grupos não capturadores: Se estiver agrupando apenas por estrutura lógica, use (?:...).
Controle o retrocesso: Use quantificadores como +, * ou {n,m} com cuidado.
Compare e teste: Use ferramentas como https://regex101.com/ ou os benchmarks nativos do Go.
Equilibre rigidez e flexibilidade: Decida desde o início quão permissivo seu padrão deve ser.