Regex-mönstergenerator

Bygg reguljära uttryck visuellt med token-block och verifierade utvecklarrecept.

Inga uppladdningarIngen registreringOmedelbara resultat
13 verifierade RFC- & dev-mallarVisuell regel- & kvantifierarbyggareJS · Python · Go · Rust-kodsnuttar
Skapa Regex
Offlinemotorn är redo100 % privat arbetsyta i webbläsaren • Inga molnuppladdningar
100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis Regex-mönstergenerator?

Byggd från grunden för strikt integritet, snabb körning och utan krångel. Inga prenumerationer eller konton krävs.

Komponerbara visuella token-block

Konstruera läsbara reguljära uttryck steg för steg genom att kedja ihop ankare, teckenklasser, begränsade kvantifierare, icke-fångande grupper ((?:...)) och namngivna fångstgrupper ((?<name>...)).

RFC-anpassade utvecklarrecept

Ladda verifierade mallar för praktiska e-postadresser enligt RFC 5322, avgränsade IPv4/IPv6-adresser, ISO-8601- / RFC 3339-tidsstämplar, SemVer 2.0.0-taggar, RFC 9562 UUID:er, URL:er, URL-sluggar och hexadecimala CSS-färger.

Kodsnuttar för flera språk

Exportera kompileringsklar kod för JavaScript (RegExp), Python (re.compile råsträngar), Go (regexp.MustCompile råliteraler) och Rust (regex::Regex) med automatisk anpassning av syntax för namngivna grupper.

Omedelbar fixturvalidering & integritet

Verifiera positiva och negativa teststrängar i realtid medan du justerar blocken. Varje mallanpassning, valideringskörning och kodexport körs till 100 % på klientsidan utan några nätverksanrop.

Utiliome jämfört med molnalternativ

Jämför vår lokala WebAssembly-motor med äldre molnverktyg.

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
Komponerbara visuella token-block Konstruera läsbara reguljära uttryck steg för steg genom att kedja ihop ankare, teckenklasser, begränsade kvantifierare, icke-fångande grupper ((?:...)) och namngivna fångstgrupper ((?<name>...)). Begränsade alternativ utan avancerad anpassning
RFC-anpassade utvecklarrecept Ladda verifierade mallar för praktiska e-postadresser enligt RFC 5322, avgränsade IPv4/IPv6-adresser, ISO-8601- / RFC 3339-tidsstämplar, SemVer 2.0.0-taggar, RFC 9562 UUID:er, URL:er, URL-sluggar och hexadecimala CSS-färger. Kräver externa verktyg eller manuell hantering
Integritet och databehandling 100 % lokalt i webbläsaren (ingen serveruppladdning) Laddar upp data till externa molnservrar
Pris och kontokrav 100 % gratis för alltid utan registrering Kräver kontoregistrering eller betald prenumeration
Så fungerar det

Hur du använder Regex-mönstergenerator i 3 enkla steg

Ingen programinstallation krävs. Allt körs direkt i din webbläsare.

1

Välj ett verifierat recept eller lägg till token-block

Välj en RFC-testad förinställning (e-post, IPv4/IPv6, ISO-8601-datum, SemVer, UUID, URL, slug eller hexfärg) eller lägg till ankare, teckenmängder, literaler och kvantifierare visuellt.

2

Konfigurera ankare, grupper och teststrängar

Växla mellan exakt strängvalidering (^...$) och delsträngsmatchning, tilldela namngivna ((?<name>...)) eller icke-fångande ((?:...)) grupper och kontrollera mot positiva och negativa testfixturer.

3

Kopiera rå regex eller flerspråkig kod

Exportera det råa mönstret eller kopiera idiomatiska kodsnuttar för JavaScript, Python, Go eller Rust med korrekt råsträngs-escaping och motorspecifik fångstsyntax.

Komponera ett produktionsmönster från visuella token-block till flerspråkig kod

Snabbsvar: Kedja ihop förankrade token-block sekventiellt, tilldela semantiska fältnamn via namngivna fångstgrupper ((?<name>...)), validera mot positiva och negativa gränsfallsfixturer och exportera idiomatiska råsträngssnuttar anpassade för JavaScript, Python, Go och Rust.

Att skriva kompakta reguljära uttryck för hand ur minnet introducerar ofta subtila buggar – såsom oescapade punkter (. som matchar valfritt tecken istället för en bokstavlig .), saknade start-/slutankare eller buggar med inledande nollor. Med visuell token-komposition kan vi anta att du behöver en strikt validerare för Semantic Versioning 2.0.0 (SemVer) som accepterar ett valfritt v-prefix och extraherar identifierare för major, minor, patch, prerelease och build-metadata.

Varje strukturell regel mappas tydligt till en explicit sekvens av token-block:

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

Lägg märke till hur 0|[1-9]\d* upprätthåller SemVer 2.0.0 sektion 2 genom att tillåta 0 samtidigt som inledande nollor som 01 avvisas, och hur icke-fångande omslag (?:...)? kapslar in avgränsarna - och + utan att skapa extra numrerade grupper. Validering mot positiva och negativa fixturer samt export av flerspråkig kod genererar automatiskt korrekta deklarationer för respektive motor:

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

Eftersom generatorn undviker bakåtreferenser och lookarounds i standardrecepten kompileras det exporterade uttrycket utan ändringar i linjärtidsbaserade RE2-miljöer (Go och Rust) såväl som i backtracking-motorer (JavaScript och Python).

Portabilitet mellan regex-motorer, nyanser i RFC-validering och escaping-regler

Snabbsvar: Exekveringsmiljöer för reguljära uttryck delas in i backtracking-NFA:er (JavaScript RegExp, Python re) och linjärtidsbaserade Thompson NFA- / DFA-motorer (Go regexp, Rust regex). Portabla mönster undviker lookarounds och bakåtreferenser, använder inbyggda råsträngsliteraler och upprätthåller exakta oktett- och nibble-gränser enligt RFC.

Backtracking-NFA kontra linjärtidsautomater (Go RE2 och Rust `regex`)

Produktionsmotorer för reguljära uttryck delas in i två distinkta exekveringsmodeller:

  1. Backtracking-NFA (JavaScript RegExp, Python re): Utforskar alterneringsgrenar rekursivt, vilket möjliggör bakåtreferenser (\1, \k<name>) och godtyckliga lookahead-/lookbehind-uttryck ((?=...), (?!...), (?<=...), (?<!...)), till priset av potentiell exponentiell körtid i värsta fall vid tvetydiga mönster.
  2. Thompson NFA / Lazy DFA (Go regexp, Rust regex): Flyttar fram alla aktiva automattillstånd synkront per inmatad byte eller kodpunkt, vilket garanterar tidskomplexiteten O(m * n) i värsta fall utifrån mönsterstorlek m och indatalängd n. För att bevara ändliga tillståndsgränser exkluderar Go regexp och Rust regex medvetet bakåtreferenser och lookarounds.

Syntaxen för namngivna fångstgrupper varierar också mellan standardbiblioteken: ECMAScript kräver (?<name>...); Python re och Go regexp kräver (?P<name>...); Rust regex (1.9+) accepterar både (?<name>...) och (?P<name>...).

Escaping av råsträngar i värdspråket

Att bädda in ett mönster i en vanlig sträng med dubbla citattecken gör att värdkompilatorn tolkar omvända snedstreck först, vilket tvingar \d+\.\d+ att dubbleras till "\\d+\\.\\d+" och riskerar tyst datakorruption (exempelvis att "\b" förvandlas till ASCII 0x08 backsteg istället för en ordgräns). Exporterade kodsnuttar använder varje språks inbyggda råliteralform:

  • JavaScript: /pattern/flags-literalnotation (där endast oescapade snedstreck escapas som \/), eller new RegExp(String.raw..., flags) för dynamisk konstruktion.
  • Python: re.compile(r"...")-råsträngsliteraler (notera att en råsträng i Python inte kan sluta med ett udda antal omvända snedstreck).
  • Go: regexp.MustCompile med råa gravisliteraler (backticks), där \x60 ersätter ett bokstavligt gravistecken om det måste matchas.
  • Rust: regex::Regex::new(r"...") eller hashade råliteraler r#"..."# när mönstret i sig innehåller dubbla citattecken.

Precisionsgränser enligt RFC i utvecklarrecept

  • IPv4 & IPv6 (RFC 4291 / RFC 5952): Ett naivt \d{1,3}(?:\.\d{1,3}){3} accepterar ogiltiga oktetter upp till 999. Strikt IPv4-validering avgränsar varje decimal oktett via (?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d), medan IPv6-recept tar hänsyn till nollkomprimering med :: (högst en gång) och IPv4-mappade ändelser (::ffff:192.0.2.128).
  • UUID:er (RFC 9562, som ersätter RFC 4122): Den kanoniska hex-layouten 8-4-4-4-12 ^[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}$ begränsar versions-nibblen (1–8, vilket täcker UUIDv7 och UUIDv8) samt IETF-variantbitarna (8, 9, a, b), med en valfri lättnad för sentinelvärdena Nil (00000000-...) och Max (ffffffff-...).
  • ISO-8601- / RFC 3339-datum & praktiska e-postadresser: Lexikala uttryck tvingar fram avgränsade månader (0[1-9]|1[0-2]), dagar (0[1-9]|[12]\d|3[01]), timmar ([01]\d|2[0-3]) och tidszonsförskjutningar (Z|[+-](?:[01]\d|2[0-3]):[0-5]\d), medan kalenderaritmetik för skottår (såsom att avvisa 30 februari) och SMTP-postlådeverifiering överlåts till efterföljande parserlogik.

Regex-mönstergenerator kontra Regex-testare: Vilket verktyg behöver du?

Snabbsvar: Använd Regex-mönstergenerator när du konstruerar ett nytt reguljärt uttryck visuellt från token-block, anpassar en verifierad RFC-mall eller exporterar escapad kod för JavaScript, Python, Go och Rust. Använd Regex-testare & Felsökare när du inspekterar träffpositioner, fångstlistor och strängersättningar i realtid.

Valet mellan de två verktygen beror på om du skapar ett uttryck eller diagnostiserar ett. Regex-mönstergenerator fokuserar på strukturerad sammansättning, anpassning av RFC-recept och kodgenerering över språkgränser. När du har ett färdigt uttryck och behöver inspektera varje träffposition i en flerradig nyttolast, växla tillståndsberoende ECMAScript-flaggor eller förhandsgranska $<name>-strängersättningar öppnar du Regex-testare & Felsökare.

Kapacitet Regex-mönstergenerator Regex-testare & Felsökare
Primär utvecklaruppgift Bygg nya mönster visuellt eller anpassa verifierade RFC-recept Felsök befintliga mönster, träffpositioner, flaggor och ersättningar
Mönsterkonstruktion Komponerbara token-block (ankare, klasser, kvantifierare, namngivna grupper) Direkt redigering av reguljära uttryck i fritext
Verifierat receptbibliotek Inbyggda mallar för E-post, IPv4/IPv6, ISO-8601, SemVer, UUID, URL, Slug, Hex Fokuserad på godtyckliga användardefinierade mönster och loggdata
Flerspråkig kodexport Kopieringsklara kodsnuttar för JavaScript, Python, Go och Rust Utdata som JavaScript- / ECMAScript-regexliteral
Inspektion av fångster & positioner Omedelbar validering mot positiva och negativa fixturer [start, end)-intervall per träff, $1–$99-fångster och (?<name>...)-uppslagsverk
Förhandsgranskning av ersättningar Inte utformad för förhandsgranskning av strängersättningar Förhandsgranskning av replace / replaceAll i realtid ($1, $<name>, $&, $$)

Rekommenderat arbetsflöde

Bygg ihop ditt grunduttryck eller ladda en RFC-mall här i Regex-mönstergenerator för att få en ren gruppstruktur, linjärtidsanpassade kvantifierargränser och korrekt escapad standardkod för ditt backend- eller frontendspråk. När du sedan behöver testa hur mönstret samverkar med flerradiga loggfiler, lastIndex-tillstånd, Unicode-surrogatpar eller replaceAll-mallar lämnar du över mönstret till Regex-testare & Felsökare.

FAQ

Regex-mönstergenerator FAQ och teknisk guide

Allt du behöver veta om att använda Utiliomes gratis regex generator online.

Varför skiljer sig den genererade regex-syntaxen mellan JavaScript, Python, Go och Rust?

Även om grundläggande teckenklasser och kvantifierare är identiska mellan språken skiljer sig syntaxen för namngivna fångstgrupper och automaternas begränsningar. JavaScript kräver (?<name>...), medan Pythons re-modul och Gos regexp-paket kräver (?P<name>...) (Rusts regex-crate stöder båda formerna). Dessutom kompilerar Go och Rust mönster till linjärtidsbaserade Thompson NFA- / DFA-tillståndsmaskiner som avsiktligt utelämnar bakåtreferenser (\1) och lookarounds ((?=...), (?<=...)), medan backtracking-motorerna i JavaScript och Python stöder dem.

Bör jag validera e-postadresser med ett reguljärt uttryck för hela RFC 5322-grammatiken?

Nej. En bokstavlig RFC 5322-grammatik sträcker sig över flera kilobyte för att tillåta föråldrade citerade blanksteg, nästlade kommentarer och IP-literaldomäner som moderna e-postservrar avvisar, utan att bevisa huruvida en postlåda faktiskt kan ta emot e-post. Produktionstjänster kombinerar ett koncist strukturellt mönster (^[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])?)+$) med längdgränser i byte enligt RFC 5321 (64 oktetter för lokal del, 254 oktetter för hela adressen) samt utskick av bekräftelsemejl.

Hur förhindrar råsträngsliteraler buggar med dubbel-escaping av omvända snedstreck mellan olika språk?

I vanliga citerade strängar bearbetar värdkompilatorn escape-sekvenser med omvända snedstreck innan strängen skickas vidare till regex-kompilatorn, vilket kräver att \d+\s+ dubbleras till "\\d+\\s+" och gör att "\b" tolkas som ett ASCII-backstegstecken istället för en ordgräns. Inbyggda råliteraler kringgår värdspråkets tolkning av omvända snedstreck: använd /\d+\s+/-literaler i JavaScript, r"\d+\s+" i Python, gravisliteraler (backticks) i Go samt r"\d+\s+" eller r#"..."# i Rust.

Vad är skillnaden mellan exakt strängvalidering och extrahering av delsträngar?

Exakt validering kapslar in hela uttrycket i start- och slutankare (^...$, eller \A...\z i Python, Go och Rust, där $ i Python re även kan matcha precis före ett avslutande \n). Utan ankare fungerar ett datumuttryck som \d{4}-\d{2}-\d{2} som en delsträngssökning och ger träff på felformaterade indata som foo-2026-11-01-bar. Behåll exakt förankring aktiverad för validering av API-nyttolaster och formulär, eller testa oförankrade extraheringsintervall i Regex-testare & Felsökare.

Hur skiljer UUID-receptet för RFC 9562 giltiga UUID:er från godtyckliga hex-strängar på 36 tecken?

RFC 9562 (som ersätter RFC 4122) kodar 4-bitars versionsnumret i den höga nibblen av den tredje gruppen ([1-8] för UUIDv1 till och med UUIDv8) och IETF-varianten i den höga nibblen av den fjärde gruppen ([89abAB], vilket representerar binärt 10xx). Om din databas även lagrar Nil-UUID med bara nollor (00000000-0000-0000-0000-000000000000) eller Max-UUID med bara ettor (ffffffff-ffff-ffff-ffff-ffffffffffff) kan du aktivera den mindre strikta hex-varianten eller lägga till explicita alterneringsgrenar.