Validateur regex Go d'e-mail

Qu'est-ce que le regex d'e-mail en Go ?

En Go (Golang), le regex d'e-mail permet de vérifier si une chaîne est une adresse e-mail valide. Cela est couramment nécessaire pour :

• La validation de champs de formulaire lors de l'inscription utilisateur

• Les contrôles d'entrée d'API backend

• La désinfection des saisies utilisateur

• Les workflows de connexion et de récupération de compte

Le package regexp de Go offre une gestion regex efficace et performante qui facilite l'implémentation de ces contrôles avec précision et rapidité.

Pourquoi valider les e-mails en Go ?

La validation des e-mails est une partie essentielle de toute application traitant des comptes utilisateur ou des communications. Des adresses e-mail invalides peuvent entraîner des notifications échouées, des risques de sécurité et de mauvaises expériences utilisateur. Que vous construisiez des workflows d'authentification, des formulaires d'inscription ou des éditeurs de profil, une validation robuste garantit que seuls des e-mails correctement formatés entrent dans votre système.

Approches populaires pour la validation d'e-mails en Go

Il existe plusieurs façons de valider des adresses e-mail en Go, chacune avec ses propres atouts :

• Expressions régulières (Regex) : Idéal pour vérifier rapidement si une chaîne e-mail correspond à un pattern courant. Le regex est très flexible et personnalisable, ce qui en fait le choix privilégié pour la plupart des validations de formulaires et d'API.

• Packages natifs : Go propose le package net/mail qui peut analyser les adresses e-mail pour la conformité RFC. Cette méthode est utile lorsque vous avez besoin d'une validation plus stricte.

• Bibliothèques tierces : Pour une validation encore plus avancée, incluant les vérifications DNS ou la détection d'e-mails jetables, des packages externes peuvent être exploités.

Validation vs. vérification des e-mails

Il est facile de confondre validation et vérification des e-mails, elles sonnent similaire mais remplissent des rôles distincts.

La validation des e-mails vérifie si une adresse e-mail est correctement formatée et exempte de fautes de frappe.

La vérification des e-mails va plus loin. Elle confirme que l'e-mail est réel et appartient bien à l'utilisateur, en envoyant généralement un lien ou un code de confirmation.

Exemple de pattern regex d'e-mail

Un regex compatible Go couramment utilisé pour la validation d'e-mails :

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

Correspond à :

• user@example.com

• john.doe_92@company.co

• test+1@domain.in

Ne correspond pas à :

• user@.com

• user@domain

• user@domain..com

Une approche plus simple et souvent préférable : net/mail

Avant de vous perdre dans les méandres du regex, rappelez-vous que la bibliothèque standard de Go propose un analyseur d'e-mails intégré : net/mail. Il est souvent plus sûr (et plus conforme à la RFC 5322) que tout regex maison.

Validation rapide en Go :

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

Attention : Le package net/mail suit la spécification RFC 5322. Ce parser vérifie la correction formelle, pas la délivrabilité ou l'existence du domaine.

Fonctionnalités et avantages clés

• Utilise le moteur regexp natif de Go

• Capture de groupes et mise en évidence des correspondances

• Retour en temps réel et validation instantanée

• Idéal pour les formulaires de connexion, d'inscription ou de profil

• Fonctionne parfaitement avec les e-mails fictifs du Générateur d'e-mail

Métacaractères utiles

• ^ : Début de chaîne

• $ : Fin de chaîne

• . : Tout caractère sauf saut de ligne

• + : Un ou plusieurs

• * : Zéro ou plusieurs

• ? : Facultatif

• [a-zA-Z0-9._%+-] : Ensemble de caractères valides pour un e-mail

• @ : Signe arobase littéral

• \\ : Utilisé pour échapper des caractères dans le regex Go

Constructions regex Go essentielles

Ancres

• ^ : Début de chaîne

• $ : Fin de chaîne

Classes de caractères

• [a-zA-Z0-9._%+-] : Caractères standard autorisés avant l'arobase

• [a-zA-Z0-9.-] : Caractères du nom de domaine

• [a-zA-Z]{2,} : Assure que le TLD comporte au moins deux caractères

Exemples de regex d'e-mail pour Go

Exemple 1 : Validation d'e-mail basique

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))
}

Essayez des variations dans le Testeur regex Go

Exemple 2 : Détection d'e-mails invalides

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

Exemple 3 : Correspondance insensible à la casse

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

Validation personnalisée avec go-playground/validator

Parfois la validation d'e-mail intégrée ne suffit pas. Avec le populaire go-playground/validator, il est facile d'ajouter vos propres règles.

1. Définissez votre fonction personnalisée

   import (
   "strings"
   "github.com/go-playground/validator/v10"
   )
   func mustCompanyDomain(fl validator.FieldLevel) bool {
   return strings.HasSuffix(fl.Field().String(), "@mycompany.com")
   }

2. Enregistrez-la sur votre validateur

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

3. Appliquez le tag dans vos structs

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

4. Validez et vérifiez les erreurs

   applicant := Signup{Email: "tester@mycompany.com"}
   err := v.Struct(applicant)
   if err != nil {
   // Traiter l'e-mail invalide
   }

Packages externes pour la validation d'e-mails en Go

go-playground/validator

Idéal pour valider non seulement les e-mails, mais aussi de nombreux champs de struct dans votre application Go. Permet la validation de format, des validateurs personnalisés et des rapports d'erreurs détaillés. Ne nécessite pas d'accès réseau pour les vérifications DNS ou SMTP.

AfterShip/email-verifier

Ajoute des vérifications avancées : validation syntaxique, vérifications DNS/MX, vérifications SMTP, détection d'e-mails jetables, identification de fournisseurs gratuits et d'adresses basées sur des rôles, ainsi que la détection de domaines catch-all.

go get github.com/AfterShip/email-verifier

Règles de validation appliquées par le package net/mail de Go

• La partie locale (avant l'arobase) ne peut pas commencer ni se terminer par un point et est limitée à 64 caractères.

• Les domaines doivent inclure au moins un point, ne peuvent pas commencer ni finir par un tiret ou un point, et ne doivent pas contenir de points consécutifs.

• L'adresse complète est limitée à 254 caractères.

• Les espaces, virgules et autres caractères interdits ne sont autorisés nulle part dans l'e-mail.

Comment fonctionne la vérification d'e-mail en Go

1. Générer un token de vérification

Après qu'un utilisateur soumet son e-mail, votre backend Go crée un token unique, souvent un token JWT, qui encode l'adresse e-mail et une heure d'expiration.

2. Envoyer l'e-mail de vérification

Le serveur envoie un e-mail contenant un lien de vérification. Ce lien pointe vers un endpoint frontend ou backend et inclut le token comme paramètre de requête.

3. L'utilisateur clique sur le lien

Votre serveur Go analyse le token, vérifie sa validité et son expiration, puis extrait l'e-mail intégré.

4. Activer le compte

Si le token est valide, le serveur marque l'e-mail de l'utilisateur comme vérifié dans votre base de données.

Comment l'utiliser

1. Collez votre pattern regex compatible Go.

2. Saisissez des exemples d'e-mails de test.

3. Voyez instantanément si votre pattern correspond et quelles parties sont capturées.

4. Ajustez et testez avec des e-mails réalistes grâce à nos générateurs.

Conseils pro pour le regex d'e-mail en Go

• Utilisez regexp.MustCompile pour les regex prédéfinis afin d'éviter les erreurs à l'exécution.

• Testez toujours avec des cas limites comme : TLD manquant (name@domain), points consécutifs (john..doe@example.com), entrées en majuscules (TEST@EMAIL.com).

• Le regex valide uniquement la structure, pas l'existence réelle du domaine.

• Pour une validation plus stricte, notez que Go ne supporte pas les lookbehind.

Associez-le à ces outils

• Générateur d'e-mail : obtenez des e-mails valides aléatoires pour tester votre regex.

• Générateur de mots de passe : testez les workflows d'inscription e-mail et mot de passe.

• Générateur de noms d'utilisateur : ajoutez du réalisme aux profils utilisateur simulés.

• Générateur d'adresses : complétez vos tests de formulaires avec des données de localisation.

• Générateur de clés API : pour les intégrations basées sur l'authentification.

• Générateur de numéros de téléphone : ajoutez la validation de saisie téléphonique à vos formulaires.

Regex pour d'autres langages

• JavaScript : Utilisez le Testeur regex JavaScript

• Java : Essayez le Testeur regex Java

• Python : Testez dans le Testeur regex Python

Erreurs courantes dans le regex d'e-mail

• Utiliser des patterns trop stricts qui bloquent des e-mails valides contenant + ou des sous-domaines.

• Oublier d'échapper le . dans le domaine.

• Ne pas prendre en compte les TLD de plus de 4 caractères.