E-Mail-Regex-Go-Validator

Der Qodex E-Mail-Regex-Go-Validator hilft Ihnen dabei, E-Mail-Adressmuster mit dem regexp-Paket von Golang zu testen und zu validieren. Ob Sie Backend-Validierungen schreiben oder an Anmelde-Flows arbeiten, dieses Tool zeigt sofortige Match-Ergebnisse und Gruppen-Captures. Verwenden Sie es zusammen mit unserem E-Mail-Generator, dem Benutzernamen-Generator oder dem Passwort-Generator, um realitätsnahe Testszenarien zu simulieren.

E-Mail-Regex-Go-Validator, Dokumentation

Was ist Go-E-Mail-Regex?

In Go (Golang) wird E-Mail-Regex verwendet, um zu prüfen, ob ein gegebener String eine gültige E-Mail-Adresse ist. Dies wird häufig benötigt für:

Formularfeld-Validierung bei der Benutzerregistrierung
Backend-API-Eingabeprüfungen
Bereinigung von Benutzereingaben
Login-Workflows und Kontowiederherstellung

Das regexp-Paket von Go bietet effizientes und leistungsstarkes regex-Handling, das die Implementierung dieser Prüfungen mit Genauigkeit und Geschwindigkeit erleichtert.

Warum E-Mails in Go validieren?

E-Mail-Validierung ist ein kritischer Bestandteil jeder Anwendung, die mit Benutzerkonten oder Kommunikation zu tun hat. Ungültige E-Mail-Adressen können zu fehlgeschlagenen Benachrichtigungen, Sicherheitsrisiken und schlechten Benutzererlebnissen führen. Ob Sie Authentifizierungs-Workflows, Anmeldeformulare oder Profileditoren erstellen: robuste Validierung stellt sicher, dass nur korrekt formatierte E-Mails in Ihr System gelangen.

Gängige Ansätze zur E-Mail-Validierung in Go

Es gibt mehrere Möglichkeiten, E-Mail-Adressen in Go zu validieren, jede mit ihren eigenen Stärken:

Regular Expressions (Regex): Ideal, um schnell zu prüfen, ob ein E-Mail-String einem gängigen Muster entspricht. Regex ist hochflexibel und anpassbar, was es zur bevorzugten Methode für die meisten Formular- und API-Validierungen macht.
Integrierte Pakete: Go bietet das net/mail-Paket, das E-Mail-Adressen auf RFC-Konformität parsen kann. Diese Methode ist nützlich, wenn Sie eine strengere Validierung benötigen.
Drittanbieter-Bibliotheken: Für noch fortgeschrittenere Validierung, einschließlich DNS-Prüfungen oder Erkennung von Wegwerf-E-Mails, können externe Pakete verwendet werden.

E-Mail-Validierung vs. E-Mail-Verifizierung

Es ist leicht, E-Mail-Validierung und E-Mail-Verifizierung zu verwechseln, sie klingen ähnlich, erfüllen aber unterschiedliche Aufgaben.

E-Mail-Validierung prüft, ob eine E-Mail-Adresse korrekt formatiert und frei von Tippfehlern ist. Sie stellt sicher, dass "jane.doe@company.com" legitim aussieht, und erkennt offensichtliche Probleme wie fehlende "@"-Symbole oder doppelte Punkte.

E-Mail-Verifizierung geht weiter. Sie bestätigt, dass die E-Mail real ist und dem Benutzer gehört. Dies geschieht typischerweise durch das Senden eines Bestätigungslinks oder -codes an die Adresse, sodass der Empfänger aktiv werden muss.

E-Mail-Regex-Muster-Beispiel

Ein gängiges, Go-kompatibles regex für die E-Mail-Validierung:

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

Passt auf:

user@example.com
john.doe_92@company.co
test+1@domain.in

Passt nicht auf:

user@.com
user@domain
user@domain..com

Eine einfachere und oft bessere Alternative: net/mail

Bevor Sie sich in den regex-Details verlieren, denken Sie daran, dass die Standardbibliothek von Go das integrierte E-Mail-Parsing über net/mail mitbringt. Es ist oft sicherer und RFC-konformer als jedes handgeschriebene regex.

Eine schnelle Validierung in Go:

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

Hinweis: Das net/mail-Paket folgt der RFC 5322-Spezifikation. Es prüft formale Korrektheit, nicht die tatsächliche Zustellbarkeit oder die Existenz der Domain.

Kernfunktionen und Vorteile

Verwendet die native regexp-Engine von Go
Captures Gruppen und hebt Matches hervor
Echtzeit-Feedback und Validierung
Ideal für Login-, Anmelde- oder Profilformulare
Funktioniert gut mit Dummy-E-Mails aus dem E-Mail-Generator

Nützliche Metazeichen

^: Anfang des Strings
$: Ende des Strings
.: Beliebiges Zeichen außer Zeilenumbruch
+: Eines oder mehr
*: Null oder mehr
?: Optional
[a-zA-Z0-9._%+-]: Zeichensatz für gültige E-Mail-Zeichen
@: Literal "@"-Zeichen

Grundlegende Go-Regex-Konstrukte

Anker

^: Anfang des Strings (stellt sicher, dass das Muster am Anfang beginnt)
$: Ende des Strings (stellt sicher, dass keine abschließenden Zeichen vorhanden sind)

Zeichenklassen

[a-zA-Z0-9._%+-]: Passt auf Standardzeichen, die vor dem "@" erlaubt sind
[a-zA-Z0-9.-]: Passt auf Domain-Name-Zeichen
[a-zA-Z]{2,}: Stellt sicher, dass die Top-Level-Domain mindestens zwei Zeichen hat

Beispiele für E-Mail-Regex in Go

Beispiel 1: Grundlegende E-Mail-Validierung

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

Beispiel 2: Ungültige E-Mails abfangen

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

Beispiel 3: Groß- und Kleinschreibung ignorieren

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

Benutzerdefinierte E-Mail-Validierung mit go-playground/validator

Manchmal reicht die integrierte E-Mail-Validierung nicht aus. Mit dem populären go-playground/validator-Paket ist es einfach, eigene Regeln einzubinden.

Benutzerdefinierte Funktion definieren

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

Beim Validator registrieren

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

Tag in Ihren Structs verwenden

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

Validieren und Fehler prüfen

applicant := Signup{Email: "tester@mycompany.com"}
err := v.Struct(applicant)
if err != nil {
// Ungültige E-Mail behandeln
}

Validierung mit go-playground/validator

Das go-playground/validator-Paket bietet eine vielseitige Möglichkeit, E-Mail-Formate direkt in Ihren Structs zu validieren, ohne externe Netzwerkaufrufe wie DNS- oder SMTP-Verifizierung zu benötigen.

Kernfunktionen:

Format-Validierung: Prüft, ob ein String der Standardstruktur einer E-Mail-Adresse entspricht.
Struct-Feld-Validierung: Felder mit Tags annotieren, um Prüfungen zu automatisieren.
Benutzerdefinierte Validatoren: Eigene Logik für spezielle Anforderungen erstellen.
Detaillierte Fehler: Zeigt genau, was fehlgeschlagen ist und wo.

Schnellstart: go-playground/validator einrichten

Paket installieren:

go get github.com/go-playground/validator/v10

Importieren und initialisieren:

import (
"fmt"
"github.com/go-playground/validator/v10"
)
var validate = validator.New()

Grundlegende Struct-Tag-Validierung:

type User struct {
Email string validate:"required,email"
}
func main() {
user := User{Email: "example@qodex.ai"}
err := validate.Struct(user)
if err != nil {
for _, fieldErr := range err.(validator.ValidationErrors) {
fmt.Printf("Field '%s' failed for tag '%s'", fieldErr.Field(), fieldErr.Tag())
}
} else {
fmt.Println("Validation passed!")
}
}

Validierungsregeln des net/mail-Pakets

Das net/mail-Paket in Go wendet bei der Prüfung von E-Mail-Adressen folgende Schlüsselregeln an:

Der lokale Teil (vor dem "@") darf weder mit einem Punkt beginnen noch enden und ist auf 64 Zeichen begrenzt.
Domains müssen mindestens einen Punkt enthalten, dürfen weder mit einem Bindestrich noch mit einem Punkt beginnen oder enden, und dürfen keine aufeinanderfolgenden Punkte enthalten.
Die vollständige Adresse ist auf maximal 254 Zeichen beschränkt.
Leerzeichen, Kommas und andere verbotene Zeichen sind nirgends in der E-Mail erlaubt.

So funktioniert der Validator

Fügen Sie Ihr Go-kompatibles E-Mail-Regex-Muster ein.
Geben Sie Beispiel-Test-E-Mails ein.
Sehen Sie sofort, ob Ihr Muster passt und welche Teile erfasst werden.
Passen Sie es an und testen Sie gegen realistische E-Mails mit unseren Generatoren.

Profi-Tipps für E-Mail-Regex in Go

Verwenden Sie regexp.MustCompile für vordefinierte regex, um Laufzeitfehler zu vermeiden.
Testen Sie immer mit Edge-Cases wie fehlender TLD (name@domain), aufeinanderfolgenden Punkten (john..doe@example.com) und Großbuchstaben-Eingaben (TEST@EMAIL.com).
Regex validiert nur die Struktur, nicht ob die Domain tatsächlich existiert.