Regex Patroon Generator

Bouw reguliere expressies visueel op met tokenblokken en geverifieerde RFC-recepten.

Geen uploadsGeen registratieDirect resultaat
13 Geverifieerde RFC- & dev-receptenVisuele regel- & kwantorbouwerJS · Python · Go · Rust-snippets
Genereer Regex
Offline engine gereed100% privé in-browser werkomgeving • Nul cloud-uploads
100% Privé • Geen Server Uploads

Waarom Utiliome's gratis Regex Patroon Generator gebruiken?

Van de grond af opgebouwd voor strikte privacy, directe uitvoering en nul wrijving. Geen registratie nodig.

Combineerbare Visuele Tokenblokken

Construeer leesbare reguliere expressies stap voor stap door ankers, karakterklassen, begrensde kwantoren, niet-vangende groepen ((?:...)) en benoemde captures ((?<name>...)) aan elkaar te koppelen.

RFC-conforme Developer-recepten

Laad geverifieerde presets voor praktische RFC 5322-e-mailadressen, begrensde IPv4/IPv6-adressen, ISO-8601- / RFC 3339-tijdstempels, SemVer 2.0.0-tags, RFC 9562-UUID's, URL's, URL-slugs en CSS-hex-kleuren.

Code-snippets voor Meerdere Talen

Exporteer direct compileerbare code voor JavaScript (RegExp), Python (re.compile raw strings), Go (regexp.MustCompile raw literals) en Rust (regex::Regex), waarbij de syntaxis voor benoemde groepen automatisch wordt aangepast.

Directe Fixture-validatie & Privacy

Controleer positieve en negatieve voorbeeldstrings live terwijl u blokken aanpast. Elke receptaanpassing, validatieslag en code-export draait 100% client-side zonder netwerkverzoeken.

Utiliome vs. traditionele cloudtools

Vergelijk onze lokale WebAssembly-engine met verouderde cloudtools.

Functie Utiliome (Lokale Browser) Verouderde Cloud Converters
Combineerbare Visuele Tokenblokken Construeer leesbare reguliere expressies stap voor stap door ankers, karakterklassen, begrensde kwantoren, niet-vangende groepen ((?:...)) en benoemde captures ((?<name>...)) aan elkaar te koppelen. Beperkte opties zonder geavanceerde aanpassing
RFC-conforme Developer-recepten Laad geverifieerde presets voor praktische RFC 5322-e-mailadressen, begrensde IPv4/IPv6-adressen, ISO-8601- / RFC 3339-tijdstempels, SemVer 2.0.0-tags, RFC 9562-UUID's, URL's, URL-slugs en CSS-hex-kleuren. Vereist externe tools of handmatige bewerking
Privacy & Gegevensverwerking 100% lokale verwerking in je browser (geen uploads) Uploadt gegevens naar externe cloudservers
Prijsmodel & Accountvereisten 100% gratis voor altijd zonder registratie Vereist accountregistratie of betaald abonnement
Hoe het werkt

Hoe Regex Patroon Generator te gebruiken in 3 eenvoudige stappen

Geen software-installatie vereist. Alles draait direct in je webbrowser.

1

Kies een Geverifieerd Recept of Voeg Tokenblokken Toe

Selecteer een RFC-geteste preset (e-mail, IPv4/IPv6, ISO-8601-datum, SemVer, UUID, URL, slug of hex-kleur) of voeg visueel ankers, karaktersets, literals en kwantoren toe.

2

Configureer Ankers, Groepen en Teststrings

Schakel tussen exacte stringvalidatie (^...$) en substring-matching, wijs benoemde ((?<name>...)) of niet-vangende ((?:...)) wrappers toe en controleer positieve en negatieve test-fixtures.

3

Kopieer Ruwe Regex of Multi-language Code

Exporteer het kale patroon of kopieer idiomatische JavaScript-, Python-, Go- of Rust-snippets inclusief raw-string escaping en engine-specifieke capture-syntaxis.

Een productiepatroon samenstellen van visuele tokenblokken tot multi-language code

Kort antwoord: Koppel verankerde tokenblokken sequentieel aan elkaar, wijs semantische veldnamen toe via benoemde capture-groepen ((?<name>...)), valideer tegen positieve en negatieve edge-case fixtures en exporteer idiomatische raw-string snippets op maat voor JavaScript, Python, Go en Rust.

Het uit het hoofd uitschrijven van complexe reguliere expressies leidt vaak tot subtiele fouten—zoals niet-geëscapete punten (. matcht elk willekeurig teken in plaats van een letterlijke punt .), ontbrekende begin-/eindankers of bugs met voorloopnullen. Stel dat u via visuele tokencompositie een strikte Semantic Versioning 2.0.0 (SemVer) validator nodig heeft die een optioneel v-voorvoegsel accepteert en de identifiers major, minor, patch, prerelease en build-metadata extraheert.

Elke structurele regel laat zich overzichtelijk vertalen naar een expliciete reeks tokenblokken:

{
  "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 (?)"
    }
  ]
}

Merk op hoe 0|[1-9]\d* Sectie 2 van SemVer 2.0.0 afdwingt door 0 toe te staan maar voorloopnullen zoals 01 te weigeren, en hoe niet-vangende wrappers (?:...)? de scheidingstekens - en + afschermen zonder extra genummerde groepen aan te maken. Door te valideren tegen positieve en negatieve fixtures en vervolgens multi-language code te exporteren, krijgt u automatisch engine-specifieke declaraties:

# 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-]+)*))?$`)

Omdat de generator in standaardrecepten geen backreferences en lookarounds gebruikt, compileert de geëxporteerde expressie zonder aanpassingen zowel in lineaire RE2-runtimes (Go en Rust) als in backtracking-engines (JavaScript en Python).

Portabiliteit tussen regex-engines, RFC-validatienuances en escaping-regels

Kort antwoord: Reguliere-expressie-runtimes zijn onderverdeeld in backtracking-NFA's (JavaScript RegExp, Python re) en Thompson NFA / DFA-engines met lineaire uitvoeringstijd (Go regexp, Rust regex). Overdraagbare patronen vermijden lookarounds en backreferences, gebruiken native raw string literals en dwingen exacte RFC-octet- en nibble-grenzen af.

Backtracking-NFA's versus Automaten met Lineaire Tijd (Go RE2 en Rust `regex`)

Productie-engines voor reguliere expressies vallen uiteen in twee verschillende uitvoeringsmodellen:

  1. Backtracking-NFA (JavaScript RegExp, Python re): Doorloopt alternatievertakkingen recursief, wat backreferences (\1, \k<name>) en willekeurige lookahead-/lookbehind-assertions ((?=...), (?!...), (?<=...), (?<!...)) mogelijk maakt, maar met het risico op exponentiële worst-case uitvoeringstijd bij dubbelzinnige patronen.
  2. Thompson NFA / Lazy DFA (Go regexp, Rust regex): Zet alle actieve automaattoestanden synchroon per invoerbyte of codepoint voort, wat een worst-case tijdscomplexiteit van O(m * n) garandeert in patroongrootte m en invoerlengte n. Om eindige toestandsgrenzen te behouden, laten Go regexp en Rust regex backreferences en lookarounds bewust buiten beschouwing.

De syntaxis voor benoemde capture-groepen verschilt eveneens per standaardbibliotheek: ECMAScript vereist (?<name>...); Python re en Go regexp vereisen (?P<name>...); Rust regex (1.9+) accepteert zowel (?<name>...) als (?P<name>...).

Raw String Escaping in de Brontaal

Wanneer u een patroon in een gewone string met dubbele aanhalingstekens plaatst, interpreteert de compiler van de gasttaal eerst de backslash-escapes. Hierdoor moet \d+\.\d+ worden verdubbeld naar "\\d+\\.\\d+" en ontstaat het risico op stille corruptie (bijvoorbeeld "\b" dat verandert in ASCII 0x08 backspace in plaats van een woordgrens). Geëxporteerde snippets gebruiken daarom de native raw literal-vorm van elke taal:

  • JavaScript: /pattern/flags literal-notatie (waarbij alleen niet-geëscapete forward slashes worden geëscapet als \/), of new RegExp(String.raw..., flags) voor dynamische opbouw.
  • Python: re.compile(r"...") raw string literals (let op: een Python raw string mag niet eindigen op een oneven aantal backslashes).
  • Go: regexp.MustCompile met raw backtick-literals, waarbij \x60 wordt gebruikt als er een letterlijk backtick-teken moet worden gematcht.
  • Rust: regex::Regex::new(r"...") of r#"..."# hashed raw literals wanneer het patroon zelf dubbele aanhalingstekens bevat.

Exacte RFC-grenzen in Developer-recepten

  • IPv4 & IPv6 (RFC 4291 / RFC 5952): Een naïeve \d{1,3}(?:\.\d{1,3}){3} accepteert ongeldige octetten tot 999. Strikte IPv4-validatie begrenst elk decimaal octet via (?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d), terwijl IPv6-recepten rekening houden met eenmalige :: nulcompressie en IPv4-gemapte achtervoegsels (::ffff:192.0.2.128).
  • UUID's (RFC 9562, vervangt RFC 4122): De canonieke 8-4-4-4-12 hex-indeling ^[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}$ beperkt het versie-nibble (1–8, inclusief UUIDv7 en UUIDv8) en de IETF-variantbits (8, 9, a, b), met een optionele versoepeling voor Nil (00000000-...) en Max (ffffffff-...) sentinel-waarden.
  • ISO-8601- / RFC 3339-datums & Praktische E-mails: Lexicale expressies dwingen begrensde maanden (0[1-9]|1[0-2]), dagen (0[1-9]|[12]\d|3[01]), uren ([01]\d|2[0-3]) en tijdzone-offsets (Z|[+-](?:[01]\d|2[0-3]):[0-5]\d) af, terwijl schrikkeljaarberekeningen (zoals het weigeren van 30 februari) en SMTP-mailboxverificatie worden overgelaten aan verdere parserlogica.

Regex Patroon Generator vs Regex Tester: Welke heeft u nodig?

Kort antwoord: Gebruik de Regex Patroon Generator wanneer u een nieuwe reguliere expressie visueel opbouwt uit tokenblokken, een geverifieerde RFC-preset aanpast of correct geëscapete code exporteert voor JavaScript, Python, Go en Rust. Gebruik de Regex Tester & Debugger wanneer u match-offsets, capture-dictionaries en live string-vervangingen wilt inspecteren.

De keuze tussen beide tools hangt af van de vraag of u een expressie opstelt of analyseert. Regex Patroon Generator richt zich op gestructureerde opbouw, het aanpassen van RFC-recepten en codegeneratie voor meerdere programmeertalen. Zodra u een expressie heeft en elke match-offset in een tekst met meerdere regels wilt inspecteren, stateful ECMAScript-flags wilt schakelen of $<name> string-substituties wilt voorvertonen, opent u Regex Tester & Debugger.

Functionaliteit Regex Patroon Generator Regex Tester & Debugger
Primaire Engineering-taak Nieuwe patronen visueel bouwen of geverifieerde RFC-recepten aanpassen Bestaande patronen, match-offsets, flags en substituties debuggen
Patroonopbouw Combineerbare tokenblokken (ankers, klassen, kwantoren, benoemde groepen) Directe vrije bewerking van reguliere expressies
Geverifieerde Receptenbibliotheek Ingebouwde presets voor E-mail, IPv4/IPv6, ISO-8601, SemVer, UUID, URL, Slug, Hex Gericht op willekeurige door de gebruiker ingevoerde patronen en log-payloads
Multi-language Code-export Kant-en-klare snippets voor JavaScript, Python, Go en Rust JavaScript / ECMAScript regex literal-uitvoer
Capture- & Offset-inspectie Directe validatie van positieve en negatieve test-fixtures [start, end)-bereiken per match, $1–$99 captures en (?<name>...) dictionary
Live Vervangingsvoorbeeld Niet ontworpen voor voorvertoningen van string-substituties Real-time replace / replaceAll voorbeeld ($1, $<name>, $&, $$)

Aanbevolen Workflow

Stel uw basisexpressie samen of laad een RFC-preset hier in Regex Patroon Generator voor een schone groepsstructuur, lineaire kwantorgrenzen en correct geëscapete boilerplate-code voor uw backend- of frontend-taal. Wanneer u vervolgens wilt testen hoe dat patroon omgaat met logbestanden van meerdere regels, de lastIndex-status, Unicode-surrogaatparen of replaceAll-templates, stuurt u het patroon door naar Regex Tester & Debugger.

Veelgestelde vragen

Regex Patroon Generator FAQ en Technische Gids

Alles wat je moet weten over het gebruik van Utiliome's gratis online regex generator.

Waarom verschilt de gegenereerde regex-syntaxis tussen JavaScript, Python, Go en Rust?

Hoewel de standaard karakterklassen en kwantoren overeenkomen tussen deze talen, lopen de syntaxis voor benoemde captures en de beperkingen van de onderliggende automaat uiteen. JavaScript vereist (?<name>...), terwijl de re-module van Python en het regexp-pakket van Go (?P<name>...) vereisen (de regex-crate van Rust ondersteunt beide vormen). Daarnaast compileren Go en Rust patronen naar Thompson NFA / DFA-toestandsmachines met lineaire uitvoeringstijd die bewust backreferences (\1) en lookarounds ((?=...), (?<=...)) weglaten, terwijl de backtracking-engines van JavaScript en Python deze wel ondersteunen.

Moet ik e-mailadressen valideren met een reguliere expressie die de volledige RFC 5322-grammatica volgt?

Nee. Een letterlijke RFC 5322-grammatica beslaat meerdere kilobytes om verouderde spaties tussen aanhalingstekens, geneste opmerkingen en IP-literal domeinen toe te staan die moderne mailservers weigeren, zonder te bewijzen of een mailbox daadwerkelijk e-mail kan ontvangen. Productieservices combineren een beknopt structureel patroon (^[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])?)+$) met de byte-lengtelimieten uit RFC 5321 (64 octetten voor het lokale deel, 254 octetten voor het volledige adres) en een bevestigingsmail.

Hoe voorkomen raw string literals fouten met dubbele backslash-escaping in verschillende programmeertalen?

In standaard strings tussen aanhalingstekens verwerkt de compiler van de gasttaal eerst alle backslash-escapes voordat de string wordt doorgegeven aan de regex-compiler. Daardoor moet \d+\s+ worden verdubbeld naar "\\d+\\s+" en verandert "\b" in een ASCII backspace-teken in plaats van een woordgrens. Native raw literals omzeilen deze backslash-verwerking van de gasttaal: gebruik /\d+\s+/ literals in JavaScript, r"\d+\s+" in Python, backtick-literals in Go en r"\d+\s+" of r#"..."# in Rust.

Wat is het verschil tussen exacte stringvalidatie en substring-extractie?

Exacte validatie omsluit de volledige expressie met begin- en eindankers (^...$, of \A...\z in Python, Go en Rust, aangezien $ in Python re ook direct vóór een afsluitende \n kan matchen). Zonder ankers gedraagt een datumexpressie zoals \d{4}-\d{2}-\d{2} zich als een substring-zoekopdracht en slaagt deze ook bij ongeldige invoer zoals foo-2026-11-01-bar. Laat exacte verankering ingeschakeld voor API-payloads en formuliervalidatie, of test niet-verankerde extractiebereiken in Regex Tester & Debugger.

Hoe onderscheidt het RFC 9562 UUID-recept geldige UUID's van willekeurige hex-strings van 36 tekens?

RFC 9562 (de opvolger van RFC 4122) codeert het 4-bits versienummer in het hoogste nibble van de derde groep ([1-8] voor UUIDv1 tot en met UUIDv8) en de IETF-variant in het hoogste nibble van de vierde groep ([89abAB], wat overeenkomt met binair 10xx). Als uw database ook de volledig uit nullen bestaande Nil-UUID (00000000-0000-0000-0000-000000000000) of de volledig uit enen bestaande Max-UUID (ffffffff-ffff-ffff-ffff-ffffffffffff) opslaat, schakel dan de versoepelde hex-variant in of voeg expliciete alternatievertakkingen toe.