Validador Regex de Fechas en Go

Valide fechas en formatos como YYYY-MM-DD, DD/MM/YYYY o MM-DD-YYYY con este Validador Regex de Fechas en Go. Ideal para entradas de formularios, registros de logs e informes. Pruebe sus patrones con el Tester Regex de Go y combínelo con herramientas como Regex de Email, Regex de Números y el Validador de Contraseñas para un conjunto completo de validación de datos.

Validador Regex de Fechas en Go - Documentación

Introducción: ¿Qué es el Regex de Fechas?

Validar cadenas de fecha es esencial cuando trabaja con logs, formularios de usuario, informes o cualquier entrada estructurada en su aplicación Go. Usar regex para validar fechas garantiza que los usuarios ingresen datos en el formato correcto antes de que se guarden o procesen.

En Go, la validación basada en regex funciona bien para comprobaciones básicas de formato:

YYYY-MM-DD (formato ISO)
DD/MM/YYYY (común en India y Europa)
MM-DD-YYYY (común en Estados Unidos)

En datos del mundo real, los formatos pueden variar considerablemente: separadores de puntos (por ejemplo, 12.31.2024), fechas sin ceros iniciales (1/2/2024 en vez de 01/02/2024) o incluso años de dos dígitos (12/31/24). Para construir un patrón regex robusto, es importante contemplar estas variaciones regionales y asegurarse de que la validación sea precisa y fácil de usar sin importar el origen de los datos.

Fundamentos de Regex

Para validar fechas con regex, es útil conocer los bloques básicos de construcción:

A-Z : letras mayúsculas
a-z : letras minúsculas
0-9 : dígitos
\. : un punto literal
+ : uno o más del elemento anterior
* : cero o más del elemento anterior
? : opcional (cero o uno)
^ : inicio de cadena
$ : fin de cadena

Los metacaracteres como ^ y $ anclan la coincidencia al inicio o al final de una cadena, mientras que los cuantificadores como + o {n} definen cuántas veces debe aparecer un carácter o grupo. El regex va mucho más allá de la búsqueda básica: puede validar que una cadena siga estrictamente formatos como MM/DD/YYYY, extraer datos de logs o aplicar coincidencias condicionales.

Patrones Regex de Fecha

Formato ISO (YYYY-MM-DD)

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

Coincide con: 2024-12-31
Rechaza: 2024-13-01, 2024-02-30

Este es el formato estándar utilizado en la mayoría de las APIs y bases de datos. Garantiza que el año tenga cuatro dígitos, el mes vaya de 01 a 12 y el día sea válido para su mes.

Formato DD/MM/YYYY

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

Coincide con: 31/12/2024
Rechaza: 00/00/2024, 32/01/2024

Este formato es habitual en India y gran parte de Europa. El patrón verifica estrictamente los ceros iniciales y usa la barra diagonal (/) como separador.

Formato MM-DD-YYYY

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

Coincide con: 12-31-2024
Rechaza: 13-01-2024, 00-15-2022

Ampliamente utilizado en Estados Unidos, este formato usa el guion (-) como separador y espera dos dígitos tanto para el mes como para el día.

Construcción de un Regex para Fechas MM/DD/YYYY

Para validar fechas en formato MM/DD/YYYY siga estos pasos:

Mes de dos dígitos: Use (0[1-9]|1[0-2]) para garantizar que el mes esté entre 01 y 12.
Separador: Use [/-] para aceptar barra diagonal o guion.
Día de dos dígitos: Use (0[1-9]|[12]\d|3[01]) para cubrir del 01 al 31.
Año de cuatro dígitos: Use \d{4}.

Patrón completo:

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

Coincide con: 12/31/2024, 01-01-2023
Rechaza: 00/10/2024, 13/28/2024

Compatibilidad con Otras Variaciones Comunes

Las fechas pueden presentar diferentes separadores: guiones (-), barras (/) o incluso puntos (.). Para contemplar todas estas variaciones, use patrones como:

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

Permite días y meses de uno o dos dígitos
Acepta /, - o . como separadores
Maneja años de dos y cuatro dígitos

Cómo Validar Fechas con Regex en Go

A continuación se muestra un programa en Go que verifica si una cadena de fecha tiene el formato ISO correcto (YYYY-MM-DD):

package main
import (
"fmt"
"regexp"
)
func isValidDate(date string) bool {
// Regex para 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 de la Validación Regex de Fechas

Validación de Formularios: Verifique si los usuarios ingresaron su fecha de nacimiento o fecha de cita en el formato correcto.
Limpieza de Datos: Identifique y elimine fechas mal formadas en grandes conjuntos de datos CSV o JSON.
Seguridad: Prevenga inyecciones de fechas o explotaciones de cadenas mal formadas en APIs y formularios.
Filtrado de Logs: Analice entradas de logs que contengan cadenas de fecha.

Consejos Profesionales

Use regex para validación a nivel de formato, pero también verifique si la fecha realmente existe (por ejemplo, el 30 de febrero no es válido).
Para formatos de hora, extienda el regex (por ejemplo, ^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$ para marcas de tiempo).
Pruebe el regex con el Tester Regex de Go antes de aplicarlo en producción.

Eficiencia del Regex

Omita rangos de clases de caracteres innecesarios para mantener los patrones simples y eficientes.
Use grupos sin captura cuando los paréntesis sean solo para agrupación: (?:...).
Considere cuantificadores posesivos o grupos atómicos para evitar el retroceso excesivo en patrones complejos.

Errores Comunes a Evitar

Olvidar requerir ceros iniciales en meses o días.
No limitar el rango de meses y días, lo que permite valores como 99 pasar la validación.
El regex no puede detectar fechas imposibles: el 30 de febrero pasará si no se agrega una comprobación adicional.

Implementación en Múltiples Lenguajes

JavaScript: Use el método .test() del objeto RegExp.

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

Python: Use el módulo re con re.match() o 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 comprobaciones rápidas.

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

Java: Use Pattern y Matcher.

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

Optimización del Regex para Rendimiento y Legibilidad

Simplifique siempre que sea posible: Use el patrón más corto que resuelva el problema.
Prefiera grupos sin captura: Use (?:...) cuando agrupe solo por estructura lógica.
Controle el retroceso: Evite patrones largos o ambiguos que puedan causar problemas de rendimiento.
Realice pruebas de referencia: Use herramientas como https://regex101.com/ o los benchmarks integrados de Go.
Equilibre rigor y flexibilidad: Decida desde el principio qué tan permisivo debe ser su patrón.