Regex-Pattern-Generator

Erstellen Sie reguläre Ausdrücke visuell mit Token-Blöcken und geprüften RFC-Vorlagen.

Kein Upload nötigOhne RegistrierungSofortige Ergebnisse
13 geprüfte RFC- & Dev-VorlagenVisueller Regel- & Quantifizierer-BaukastenJS · Python · Go · Rust-Snippets
Regex generieren
Offline-Engine bereit100 % privater Browser-Arbeitsbereich • Keine Cloud-Uploads
100% Privat • Keine Server-Datei-Uploads

Warum das kostenlose Regex-Pattern-Generator von Utiliome nutzen?

Entwickelt für höchsten Datenschutz, sofortige Ausführung und einfache Nutzung. Keine Abos oder Registrierungen erforderlich.

Kombinierbare visuelle Token-Blöcke

Konstruieren Sie lesbare reguläre Ausdrücke Schritt für Schritt, indem Sie Anker, Zeichenklassen, begrenzte Quantifizierer, nicht-erfassende Gruppen ((?:...)) und benannte Captures ((?<name>...)) verketten.

RFC-konforme Entwickler-Vorlagen

Laden Sie verifizierte Presets für praxisnahe RFC-5322-E-Mails, begrenzte IPv4/IPv6-Adressen, ISO-8601- / RFC-3339-Zeitstempel, SemVer-2.0.0-Tags, RFC-9562-UUIDs, URLs, URL-Slugs und CSS-Hex-Farben.

Multi-Language-Code-Snippets

Exportieren Sie kompilierfertigen Code für JavaScript (RegExp), Python (re.compile Raw-Strings), Go (regexp.MustCompile Raw-Literale) und Rust (regex::Regex) mit automatischer Anpassung benannter Gruppen.

Sofortige Fixture-Validierung & Datenschutz

Prüfen Sie positive und negative Test-Strings live beim Anpassen der Blöcke. Jede Vorlagenanpassung, Validierung und jeder Code-Export läuft zu 100 % clientseitig im Browser ohne Netzwerkaufrufe.

Utiliome vs. traditionelle Cloud-Tools

Vergleichen Sie unsere lokale WebAssembly-Engine mit alten Cloud-Tools.

Funktion Utiliome (Lokaler Browser) Klassische Cloud-Konverter
Kombinierbare visuelle Token-Blöcke Konstruieren Sie lesbare reguläre Ausdrücke Schritt für Schritt, indem Sie Anker, Zeichenklassen, begrenzte Quantifizierer, nicht-erfassende Gruppen ((?:...)) und benannte Captures ((?<name>...)) verketten. Eingeschränkte Optionen ohne erweiterte Anpassung
RFC-konforme Entwickler-Vorlagen Laden Sie verifizierte Presets für praxisnahe RFC-5322-E-Mails, begrenzte IPv4/IPv6-Adressen, ISO-8601- / RFC-3339-Zeitstempel, SemVer-2.0.0-Tags, RFC-9562-UUIDs, URLs, URL-Slugs und CSS-Hex-Farben. Erfordert externe Tools oder manuelle Nachbearbeitung
Datenschutz & Verarbeitung 100 % lokale Browser-Verarbeitung (null Server-Uploads) Lädt Daten auf externe Cloud-Server hoch
Preismodell & Konto-Pflicht Dauerhaft 100 % kostenlos ohne Registrierung Erfordert Registrierung oder kostenpflichtiges Abo
So funktioniert's

Regex-Pattern-Generator in 3 einfachen Schritten nutzen

Keine Softwareinstallation erforderlich. Alles läuft direkt in Ihrem Webbrowser.

1

Geprüfte Vorlage wählen oder Token-Blöcke hinzufügen

Wählen Sie ein RFC-geprüftes Preset (E-Mail, IPv4/IPv6, ISO-8601-Datum, SemVer, UUID, URL, Slug oder Hex-Farbe) oder fügen Sie Anker, Zeichenmengen, Literale und Quantifizierer visuell hinzu.

2

Anker, Gruppen und Test-Strings konfigurieren

Wechseln Sie zwischen exakter String-Validierung (^...$) und Substring-Suche, weisen Sie benannte ((?<name>...)) oder nicht-erfassende ((?:...)) Gruppen zu und prüfen Sie positive wie negative Testfälle.

3

Rohes Regex-Pattern oder Sprach-Snippets kopieren

Exportieren Sie das reine Pattern oder kopieren Sie idiomatische JavaScript-, Python-, Go- oder Rust-Snippets inklusive korrektem Raw-String-Escaping und engine-spezifischer Capture-Syntax.

Vom visuellen Token-Block zum produktionsreifen Multi-Language-Pattern

Schnelle Antwort: Verketten Sie verankerte Token-Blöcke sequenziell, vergeben Sie semantische Feldnamen über benannte Capture-Gruppen ((?<name>...)), validieren Sie positive und negative Edge-Case-Fixtures und exportieren Sie idiomatische Raw-String-Snippets für JavaScript, Python, Go und Rust.

Wer komplexe reguläre Ausdrücke aus dem Gedächtnis von Hand schreibt, baut schnell subtile Fehler ein – etwa nicht maskierte Punkte (. trifft jedes beliebige Zeichen statt eines literalen Punkts .), fehlende Start-/End-Anker oder Bugs durch führende Nullen. Angenommen, Sie benötigen mittels visueller Token-Komposition einen strikten Validator für Semantic Versioning 2.0.0 (SemVer), der ein optionales v-Präfix akzeptiert und die Bezeichner major, minor, patch, prerelease sowie build-Metadaten extrahiert.

Jede strukturelle Regel lässt sich sauber auf eine explizite Abfolge von Token-Blöcken abbilden:

{
  "anchoring": "exact_line (^...$)",
  "blocks": [
    { "type": "literal", "value": "v", "quantifier": "optional (?)" },
    { "type": "named_capture", "name": "major", "pattern": "0|[1-9]\\d*" },
    { "type": "literal", "value": "." },
    { "type": "named_capture", "name": "minor", "pattern": "0|[1-9]\\d*" },
    { "type": "literal", "value": "." },
    { "type": "named_capture", "name": "patch", "pattern": "0|[1-9]\\d*" },
    {
      "type": "non_capturing",
      "pattern": "-(?<prerelease>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)",
      "quantifier": "optional (?)"
    },
    {
      "type": "non_capturing",
      "pattern": "\\+(?<build>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)",
      "quantifier": "optional (?)"
    }
  ]
}

Beachten Sie, wie 0|[1-9]\d* Abschnitt 2 der SemVer-2.0.0-Spezifikation durchsetzt, indem 0 erlaubt wird, führende Nullen wie 01 jedoch abgelehnt werden, und wie nicht-erfassende Wrapper (?:...)? die Trennzeichen - und + umschließen, ohne zusätzliche nummerierte Gruppen zu erzeugen. Die Validierung gegen positive und negative Test-Fixtures sowie der anschließende Multi-Language-Export liefern automatisch engine-konforme Deklarationen:

# Synthesized ECMAScript / Rust Pattern
^v?(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$

# Positive Fixtures (Match)
1.0.0
v2.14.3-rc.1+build.5114f85

# Negative Fixtures (Reject: leading zero in numeric version core)
v01.2.0
1.02.3

# Python (re.compile raw string + (?P<name>...) named group syntax)
SEMVER_RE = re.compile(r"^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?P<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$")

# Go (RE2 regexp.MustCompile backtick raw literal + (?P<name>...) syntax)
var semverRe = regexp.MustCompile(`^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?P<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$`)

Da der Generator in Standardvorlagen auf Rückwärtsreferenzen (Backreferences) und Lookarounds verzichtet, kompiliert der exportierte Ausdruck ohne Änderungen sowohl in RE2-Laufzeitumgebungen mit linearer Laufzeit (Go und Rust) als auch in Backtracking-Engines (JavaScript und Python).

Portabilität zwischen Regex-Engines, RFC-Validierungsdetails und Escaping-Regeln

Schnelle Antwort: Regex-Laufzeitumgebungen teilen sich in Backtracking-NFAs (JavaScript RegExp, Python re) und Thompson-NFA-/DFA-Engines mit linearer Laufzeit (Go regexp, Rust regex). Portierbare Patterns vermeiden Lookarounds und Backreferences, nutzen native Raw-String-Literale und setzen exakte RFC-Oktett- und Nibble-Grenzen durch.

Backtracking-NFAs vs. Automaten mit linearer Laufzeit (Go RE2 und Rust `regex`)

Produktive Regex-Engines basieren auf zwei grundlegend verschiedenen Ausführungsmodellen:

  1. Backtracking-NFA (JavaScript RegExp, Python re): Durchsucht Alternierungszweige rekursiv. Das ermöglicht Rückwärtsreferenzen (\1, \k<name>) sowie beliebige Lookahead-/Lookbehind-Assertions ((?=...), (?!...), (?<=...), (?<!...)), birgt jedoch bei mehrdeutigen Patterns das Risiko exponentieller Worst-Case-Laufzeiten (ReDoS).
  2. Thompson-NFA / Lazy DFA (Go regexp, Rust regex): Führt alle aktiven Automatenzustände synchron pro Eingabe-Byte bzw. Codepoint weiter und garantiert eine Worst-Case-Zeitkomplexität von O(m * n) in Abhängigkeit von Pattern-Größe m und Eingabelänge n. Um endliche Zustandsgrenzen zu wahren, schließen Go regexp und Rust regex Rückwärtsreferenzen und Lookarounds konzeptionell aus.

Auch die Syntax für benannte Capture-Gruppen unterscheidet sich je nach Standardbibliothek: ECMAScript verlangt (?<name>...); Python re und Go regexp erfordern (?P<name>...); Rust regex (ab Version 1.9+) akzeptiert sowohl (?<name>...) als auch (?P<name>...).

Raw-String-Escaping in der Host-Sprache

Wird ein Pattern in einen gewöhnlichen String mit doppelten Anführungszeichen eingebettet, interpretiert zuerst der Compiler der Host-Sprache alle Backslash-Escapes. Dadurch muss \d+\.\d+ zu "\\d+\\.\\d+" verdoppelt werden, was leicht zu stillen Fehlern führt (z. B. wird "\b" als ASCII 0x08 Backspace statt als Wortgrenze interpretiert). Exportierte Snippets verwenden daher die nativen Raw-Literale der jeweiligen Sprache:

  • JavaScript: /pattern/flags-Literalnotation (wobei nur nicht maskierte Schrägstriche als \/ maskiert werden) oder new RegExp(String.raw..., flags) für die dynamische Konstruktion.
  • Python: re.compile(r"...") Raw-String-Literale (zu beachten: ein Python-Raw-String darf nicht auf eine ungerade Anzahl von Backslashes enden).
  • Go: regexp.MustCompile mit Backtick-Raw-Literalen, wobei \x60 eingesetzt wird, falls ein literales Backtick-Zeichen gematcht werden muss.
  • Rust: regex::Regex::new(r"...") oder r#"..."# Hashed-Raw-Literale, sofern das Pattern selbst doppelte Anführungszeichen enthält.

Präzise RFC-Grenzen in Entwickler-Vorlagen

  • IPv4 & IPv6 (RFC 4291 / RFC 5952): Ein naives \d{1,3}(?:\.\d{1,3}){3} akzeptiert ungültige Oktette bis 999. Strikte IPv4-Validierung begrenzt jedes Dezimaloktett über (?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d), während IPv6-Vorlagen die einmalige ::-Nullkompression sowie IPv4-abgebildete Endungen (::ffff:192.0.2.128) berücksichtigen.
  • UUIDs (RFC 9562, Nachfolger von RFC 4122): Das kanonische 8-4-4-4-12-Hex-Format ^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$ beschränkt das Versions-Nibble (1–8, inklusive UUIDv7 und UUIDv8) und die IETF-Varianten-Bits (8, 9, a, b), optional gelockert für Nil- (00000000-...) und Max-Sentinel-Werte (ffffffff-...).
  • ISO-8601- / RFC-3339-Daten & praxisnahe E-Mails: Lexikalische Ausdrücke erzwingen gültige Grenzen für Monate (0[1-9]|1[0-2]), Tage (0[1-9]|[12]\d|3[01]), Stunden ([01]\d|2[0-3]) und Zeitzonen-Offsets (Z|[+-](?:[01]\d|2[0-3]):[0-5]\d), während Schaltjahresberechnungen (wie das Ablehnen des 30. Februars) und die SMTP-Postfachprüfung der nachgelagerten Parser-Logik überlassen bleiben.

Regex-Pattern-Generator vs. Regex-Tester: Welches Tool benötigen Sie?

Schnelle Antwort: Nutzen Sie den Regex-Pattern-Generator, wenn Sie einen neuen regulären Ausdruck visuell aus Token-Blöcken aufbauen, eine geprüfte RFC-Vorlage anpassen oder korrekt maskierten Code für JavaScript, Python, Go und Rust exportieren möchten. Nutzen Sie den Regex Tester & Debugger, um Match-Offsets, Capture-Dictionaries und Live-String-Ersetzungen zu analysieren.

Die Wahl zwischen beiden Werkzeugen hängt davon ab, ob Sie einen Ausdruck neu entwerfen oder diagnostizieren möchten. Der Regex-Pattern-Generator konzentriert sich auf die strukturierte Erstellung, das Anpassen von RFC-Vorlagen und die sprachübergreifende Code-Generierung. Sobald Sie einen Ausdruck haben und jeden Match-Offset in einem mehrzeiligen Text untersuchen, zustandsbehaftete ECMAScript-Flags umschalten oder $<name>-String-Ersetzungen in der Vorschau prüfen möchten, öffnen Sie den Regex Tester & Debugger.

Funktion Regex-Pattern-Generator Regex Tester & Debugger
Primäre Entwicklungsaufgabe Neue Patterns visuell aufbauen oder geprüfte RFC-Vorlagen anpassen Bestehende Patterns, Match-Offsets, Flags und Ersetzungen debuggen
Pattern-Aufbau Kombinierbare Token-Blöcke (Anker, Klassen, Quantifizierer, benannte Gruppen) Direkte Freiform-Bearbeitung des regulären Ausdrucks
Geprüfte Vorlagen-Bibliothek Integrierte Presets für E-Mail, IPv4/IPv6, ISO-8601, SemVer, UUID, URL, Slug, Hex Ausgerichtet auf beliebige benutzerdefinierte Patterns und Log-Payloads
Multi-Language-Code-Export Kopierfertige Snippets für JavaScript, Python, Go und Rust Ausgabe als JavaScript- / ECMAScript-Regex-Literal
Capture- & Offset-Inspektion Sofortige Validierung gegen positive und negative Test-Fixtures [start, end)-Bereiche pro Treffer, $1–$99-Captures und (?<name>...)-Dictionary
Live-Ersetzungsvorschau Nicht für die Vorschau von String-Ersetzungen ausgelegt Echtzeit-Vorschau für replace / replaceAll ($1, $<name>, $&, $$)

Empfohlener Workflow

Erstellen Sie Ihren Basisausdruck oder laden Sie ein RFC-Preset hier im Regex-Pattern-Generator, um eine saubere Gruppenstruktur, lineare Quantifizierer-Grenzen und korrekt maskierten Boilerplate-Code für Ihre Backend- oder Frontend-Sprache zu erhalten. Wenn Sie anschließend testen möchten, wie sich dieses Pattern bei mehrzeiligen Log-Dateien, dem lastIndex-Zustand, Unicode-Surrogatpaaren oder replaceAll-Templates verhält, übergeben Sie das Pattern an den Regex Tester & Debugger.

FAQ

Regex-Pattern-Generator FAQ und technische Anleitung

Alles, was Sie über die Nutzung des kostenlosen Online-regex generator von Utiliome wissen müssen.

Warum unterscheidet sich die generierte Regex-Syntax zwischen JavaScript, Python, Go und Rust?

Während grundlegende Zeichenklassen und Quantifizierer sprachübergreifend identisch sind, weichen die Syntax für benannte Captures und die Automaten-Einschränkungen voneinander ab. JavaScript verlangt (?<name>...), während Pythons re-Modul und Gos regexp-Paket (?P<name>...) erfordern (Rusts regex-Crate unterstützt beide Formen). Zudem kompilieren Go und Rust Patterns in Thompson-NFA-/DFA-Zustandsautomaten mit linearer Laufzeit, die bewusst auf Rückwärtsreferenzen (\1) und Lookarounds ((?=...), (?<=...)) verzichten, wohingegen die Backtracking-Engines von JavaScript und Python diese unterstützen.

Sollte ich E-Mail-Adressen mit einem regulären Ausdruck validieren, der die gesamte RFC-5322-Grammatik abbildet?

Nein. Eine wörtliche Umsetzung der RFC-5322-Grammatik umfasst mehrere Kilobyte, um veraltete Leerzeichen in Anführungszeichen, verschachtelte Kommentare und IP-Literal-Domains zuzulassen, die moderne Mailserver ohnehin ablehnen – und beweist trotzdem nicht, ob ein Postfach tatsächlich E-Mails empfangen kann. Produktivsysteme kombinieren ein kompaktes strukturelles Pattern (^[a-zA-Z0-9.!#$%&'*+/=?^_\x60{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$) mit den Byte-Längenlimits aus RFC 5321 (64 Oktette für den Lokalteil, 254 Oktette für die Gesamtadresse) sowie einer Bestätigungs-E-Mail.

Wie verhindern Raw-String-Literale Fehler durch doppeltes Backslash-Escaping in verschiedenen Sprachen?

In regulären Strings mit Anführungszeichen verarbeitet der Host-Compiler Backslash-Escapes, noch bevor der String an den Regex-Compiler übergeben wird. Dadurch muss \d+\s+ zu "\\d+\\s+" verdoppelt werden, und "\b" wird versehentlich zu einem ASCII-Backspace-Zeichen statt zu einer Wortgrenze. Native Raw-Literale umgehen das Backslash-Unescaping der Host-Sprache: Nutzen Sie /\d+\s+/-Literale in JavaScript, r"\d+\s+" in Python, Backtick-Literale in Go sowie r"\d+\s+" oder r#"..."# in Rust.

Was ist der Unterschied zwischen exakter String-Validierung und Substring-Extraktion?

Die exakte Validierung umschließt den gesamten Ausdruck mit Start- und End-Ankern (^...$ bzw. \A...\z in Python, Go und Rust, da $ in Python re auch unmittelbar vor einem abschließenden \n matchen kann). Ohne Anker verhält sich ein Datumsausdruck wie \d{4}-\d{2}-\d{2} wie eine Teilstring-Suche und akzeptiert auch fehlerhafte Eingaben wie foo-2026-11-01-bar. Lassen Sie die exakte Verankerung für API-Payloads und Formularvalidierungen aktiviert oder testen Sie unverankerte Extraktionsbereiche im Regex Tester & Debugger.

Wie unterscheidet die RFC-9562-UUID-Vorlage gültige UUIDs von beliebigen 36-stelligen Hex-Strings?

RFC 9562 (der Nachfolger von RFC 4122) codiert die 4-Bit-Versionsnummer im oberen Nibble der dritten Gruppe ([1-8] für UUIDv1 bis UUIDv8) und die IETF-Variante im oberen Nibble der vierten Gruppe ([89abAB], entsprechend binär 10xx). Falls Ihre Datenbank zusätzlich die komplett aus Nullen bestehende Nil-UUID (00000000-0000-0000-0000-000000000000) oder die komplett aus Einsen bestehende Max-UUID (ffffffff-ffff-ffff-ffff-ffffffffffff) speichert, aktivieren Sie die gelockerte Hex-Variante oder fügen Sie explizite Alternierungszweige hinzu.