Validateur regex Go de dates

Validez des dates au format YYYY-MM-DD, DD/MM/YYYY ou MM-DD-YYYY grâce au Validateur regex Go de dates. Idéal pour les champs de formulaire, les journaux et les rapports. Testez vos patterns avec notre Testeur regex Go, et combinez-le avec le Validateur regex Go d'e-mail, le Validateur regex Go de numéros et le Validateur regex de mot de passe pour une suite de validation complète.

Validateur regex Go de dates - Documentation

Introduction : qu'est-ce que le regex de dates ?

Valider des chaînes de dates est essentiel lorsque vous travaillez avec des journaux, des formulaires, des rapports ou toute entrée structurée dans votre application Go. Utiliser regex pour valider les dates garantit que les utilisateurs saisissent des données dans le bon format avant leur enregistrement ou traitement.

En Go, la validation par regex convient bien aux vérifications de base, comme la correspondance de format pour :

YYYY-MM-DD (format ISO)
DD/MM/YYYY (courant en Inde et en Europe)
MM-DD-YYYY (courant aux États-Unis)

Dans la pratique, les formats de dates peuvent être variés. On rencontre parfois des dates séparées par des points (ex. 12.31.2024), sans zéros de tête (1/2/2024 au lieu de 01/02/2024), ou avec des années à deux chiffres (12/31/24). Ces variations sont fréquentes lorsque les utilisateurs copient-collent depuis différentes sources ou que les données proviennent de systèmes internationaux.

Pour construire un pattern robuste, il est important de tenir compte de ces particularités régionales. Votre pattern doit accepter les tirets, les barres obliques, les points, les jours et mois à un chiffre, ainsi que les années à deux ou quatre chiffres.

Comprendre les briques de construction du regex

Pour valider des dates avec regex, voici les éléments clés :

A-Z : lettres majuscules
a-z : lettres minuscules
0-9 : chiffres
\. : un point littéral
+ : un ou plusieurs du précédent
* : zéro ou plusieurs du précédent
? : optionnel (zéro ou un)
^ : début de chaîne
$ : fin de chaîne

Un regex est une séquence de caractères formant un pattern de recherche. Les métacaractères ^ et $ ancrent la correspondance au début ou à la fin de la chaîne, tandis que les quantificateurs définissent le nombre d'occurrences attendu.

Patterns regex de dates

Format ISO (YYYY-MM-DD)

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

Correspondance : 2024-12-31
Rejet : 2024-13-01, 2024-02-30

Ce format standard est utilisé dans la plupart des API et bases de données. Il s'assure que l'année est sur quatre chiffres, le mois entre 01 et 12, et le jour valide.

Format DD/MM/YYYY

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

Correspondance : 31/12/2024
Rejet : 00/00/2024, 32/01/2024

Ce format est courant en Inde et dans une grande partie de l'Europe. Le pattern vérifie strictement les zéros de tête et utilise la barre oblique (/) comme séparateur.

Format MM-DD-YYYY

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

Correspondance : 12-31-2024
Rejet : 13-01-2024, 00-15-2022

Très utilisé aux États-Unis, ce format emploie le tiret (-) comme séparateur et attend deux chiffres pour le mois et le jour.

Construire un regex pour les dates MM/DD/YYYY

Voici comment décomposer la construction d'un regex pour ce format :

Mois à deux chiffres : utilisez (0[1-9]|1[0-2]) pour garantir un mois entre 01 et 12.
Séparateur : incluez [/-] pour accepter la barre oblique ou le tiret.
Jour à deux chiffres : (0[1-9]|[12]\d|3[01]) couvre 01 à 31.
Année à quatre chiffres : utilisez \d{4}.

Pattern complet :

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

Correspondances : 12/31/2024, 01-01-2023
Rejets : 00/10/2024, 13/28/2024

Variantes courantes

Les séparateurs varient : tirets (-), barres obliques (/) ou points (.). Certains systèmes acceptent des dates sans zéros de tête ou avec des années à deux chiffres. Pour plus de flexibilité :

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

Accepte les jours et mois à un ou deux chiffres
Accepte /, - ou . comme séparateurs
Gère les années à deux ou quatre chiffres

Comment valider des dates avec regex en Go

Voici un programme Go vérifiant qu'une chaîne de date respecte le format ISO (YYYY-MM-DD) :

package main
import (
"fmt"
"regexp"
)
func isValidDate(date string) bool {
// Regex pour 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))
}
}

Cas d'utilisation de la validation regex de dates

Validation de formulaires : vérifiez que les utilisateurs ont saisi leur date de naissance ou un rendez-vous dans le bon format.
Nettoyage de données : identifiez et supprimez les dates mal formatées dans des jeux de données CSV ou JSON.
Sécurité : évitez les injections de dates ou les exploits de chaînes malformées dans les API et formulaires.
Filtrage de journaux : analysez les entrées de journaux contenant des chaînes de dates.

Conseils avancés

Utilisez regex pour la validation de format uniquement, mais vérifiez ensuite que la date existe réellement (ex. le 30 février n'est pas valide).
Pour les formats horodatés, étendez le regex (ex. ^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$ pour les timestamps).
Testez votre regex avec le Testeur regex Go avant de l'utiliser en production.
Pour la validation en masse, combinez cet outil avec un nettoyeur CSV ou un validateur JSON.

Conseils d'efficacité pour le regex

Évitez les plages de classes de caractères inutiles : gardez vos patterns concis.
Utilisez des groupes non capturants quand les parenthèses servent uniquement au regroupement, pas à la capture.
Recourez aux quantificateurs possessifs ou aux groupes atomiques pour éviter le retour arrière (backtracking) inutile.

Pièges courants à éviter

Oublier d'exiger les zéros de tête dans les mois ou les jours.
Ne pas limiter la plage des mois et des jours.
Oublier que regex ne peut pas détecter les dates impossibles, le 30 février passerait sans vérification supplémentaire.

Implémentation dans d'autres langages

JavaScript : utilisez la méthode .test() de l'objet RegExp.

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

Python : utilisez le module re avec 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 : utilisez regexp.MatchString().

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

Java : utilisez Pattern et Matcher.

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

Optimisation du regex pour la performance et la lisibilité

Simplifiez autant que possible : préférez le pattern le plus court qui accomplit la tâche.
Préférez les groupes non capturants : utilisez (?:...) si vous regroupez uniquement pour la structure.
Limitez le retour arrière : les quantificateurs mal utilisés peuvent provoquer des problèmes de performance.
Benchmarkez et testez : utilisez des outils comme regex101.com ou le Testeur regex Go.
Équilibrez rigueur et flexibilité : un pattern trop strict peut rejeter des saisies valides ; trop souple, il laisse passer des données incorrectes.