Regex-testare & Felsökare

Testa och felsök reguljära uttryck för JavaScript lokalt i webbläsaren.

Inga uppladdningarIngen registreringOmedelbara resultat
Flaggor g · i · m · s · u · v · yFångst- & namngivna grupper + ersätt100% Lokalt • Noll Uppladdningar
Testa reguljärt uttryck
Offlinemotorn är redo100 % privat arbetsyta i webbläsaren • Inga molnuppladdningar
100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis Regex-testare & Felsökare?

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

Exakt ECMA-262 RegExp-paritet

Körs direkt mot webbläsarens inbyggda ECMAScript-motor för reguljära uttryck med omedelbar växling av flaggor för globalt (g), skiftlägesokänsligt (i), flerradigt (m), dotAll (s), Unicode (u) och sticky (y) läge.

Inspektör för Indexerade och Namngivna Fångstgrupper

Extraherar nollbaserade [start, end) UTF-16-kodintervall, numrerade delträffar ($1 till $99) och ordböcker för namngivna fångstgrupper ((?<name>...)) för varje träff över flerradiga indata.

Live-förhandsgranskning av Ersättningar och Bakåtreferenser

Utvärderar mallar för String.prototype.replace och replaceAll i realtid med $1, $<name>, $& (hela träffen), $' (suffix efter träff) samt $$ för bokstavliga dollartecken.

ReDoS-varning & Noll Uppladdning

Markerar nästlade kvantifierare som riskerar katastrofal backtracking, samtidigt som känsliga produktionsloggar, bearer-tokens och personuppgifter (PII) stannar strikt i webbläsarens lokala minne.

Utiliome jämfört med molnalternativ

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

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
Exakt ECMA-262 RegExp-paritet Körs direkt mot webbläsarens inbyggda ECMAScript-motor för reguljära uttryck med omedelbar växling av flaggor för globalt (g), skiftlägesokänsligt (i), flerradigt (m), dotAll (s), Unicode (u) och sticky (y) läge. Begränsade alternativ utan avancerad anpassning
Inspektör för Indexerade och Namngivna Fångstgrupper Extraherar nollbaserade [start, end) UTF-16-kodintervall, numrerade delträffar ($1 till $99) och ordböcker för namngivna fångstgrupper ((?<name>...)) för varje träff över flerradiga indata. 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-testare & Felsökare i 3 enkla steg

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

1

Ange Mönster och Växla Motorflaggor

Skriv ditt reguljära uttryck utan omgivande snedstreck och aktivera exakt de ECMAScript-flaggor (g, i, m, s, u, y) som används av din målplattform i JavaScript eller TypeScript.

2

Klistra in Testdata och Inspektera Träffar

Klistra in teststrängar eller ladda in en lokal loggfil för att granska markerade träffgränser, teckenindexintervall, numrerade fångstplatser och gruppkopplingar med (?<name>...).

3

Förhandsgranska Ersättningar och Kopiera Uttryck

Ange en valfri ersättningssträng med referenser som $1, $<name> eller $& för att verifiera transformerad text i realtid, och kopiera sedan din validerade regex-literal.

Felsöka Strukturerade Loggar med Namngivna Fångstgrupper och Live-ersättningar

Snabbsvar: Kombinera namngivna fångstgrupper ((?<name>...)) med flaggorna för globalt (g) och flerradigt (m) läge för att tolka strukturerade loggrader till nyckel-värde-objekt, verifiera exakta UTF-16-träffpositioner och förhandsgranska strängtransformationer med $<name> innan du driftsätter applikationskod.

När man felsöker reguljära uttryck mot flerradig telemetri eller åtkomstloggar leder subtila misstag i ankare eller kvantifierare ofta till uteblivna träffar eller förskjutna gruppindex. Betrakta två strukturerade applikationsloggrader som innehåller ISO-8601-tidsstämplar, allvarlighetsgrader, tjänste-ID:n, hexadecimalt spårnings-ID på 16 tecken, HTTP-statuskoder och svarstider med flyttal:

2026-11-01T14:22:08.419Z [ERROR] svc=checkout trace_id=4bf92f3577b34da6 status=502 latency_ms=184.7
2026-11-01T14:22:09.004Z [INFO] svc=inventory trace_id=00f067aa0ba902b7 status=200 latency_ms=12.3

För att tolka varje rad deterministiskt utan bräcklig positionsbaserad array-indexering binder du varje fält till en namngiven fångstgrupp i ECMAScript ((?<name>...)), kapslar in den valfria decimaldelen för millisekunder i en icke-fångande grupp ((?:...)) och aktiverar både g (global iteration) och m (^- och $-ankare per rad):

^(?<ts>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[(?<level>ERROR|WARN|INFO)\]\s+svc=(?<service>[a-z0-9_-]+)\s+trace_id=(?<trace>[0-9a-f]{16})\s+status=(?<status>\d{3})\s+latency_ms=(?<ms>\d+(?:\.\d+)?)$

Utan flaggan m fäster ^ och $ uteslutande vid index 0 och slutet av hela textbufferten, vilket gör att uttrycket misslyckas så fort en radbrytning (\n) skiljer posterna åt. Med gm aktiverat löser felsökaren upp varje träffiteration till både 1-baserade positionella delträffar och ett strukturerat groups-objekt:

{
  "matchIndex": 0,
  "span": [0, 99],
  "fullMatch": "2026-11-01T14:22:08.419Z [ERROR] svc=checkout trace_id=4bf92f3577b34da6 status=502 latency_ms=184.7",
  "captures": [
    "2026-11-01T14:22:08.419Z",
    "ERROR",
    "checkout",
    "4bf92f3577b34da6",
    "502",
    "184.7"
  ],
  "groups": {
    "ts": "2026-11-01T14:22:08.419Z",
    "level": "ERROR",
    "service": "checkout",
    "trace": "4bf92f3577b34da6",
    "status": "502",
    "ms": "184.7"
  }
}

När fångstgränserna är verifierade kan du testa formatering för String.prototype.replaceAll direkt i ersättningspanelen. Om du anger mallen [$<level>] $<service>: HTTP $<status> ($<ms>ms, trace=$<trace>) genereras normaliserad utdata omedelbart:

[ERROR] checkout: HTTP 502 (184.7ms, trace=4bf92f3577b34da6)
[INFO] inventory: HTTP 200 (12.3ms, trace=00f067aa0ba902b7)

ECMA-262 RegExp-motorns Semantik, Flaggmekanik och Katastrofal Backtracking

Snabbsvar: Reguljära uttryck i JavaScript körs på en backtracking-baserad NFA som definieras i ECMA-262 avsnitt 22.2, och arbetar på 16-bitars UTF-16-kodenheter såvida inte u-flaggan aktiverar fullständig matchning av Unicode-skalärvärden. Genom att undvika tvetydiga nästlade kvantifierare förhindrar man exponentiella O(2^n) ReDoS-låsningar.

Backtracking-NFA och tillståndsbaserat `lastIndex`

Till skillnad från rena DFA-motorer (Deterministic Finite Automata) implementerar ECMAScript-motorer (V8 Irregexp, JavaScriptCore Yarr, SpiderMonkey) en backtracking-baserad icke-deterministisk finit automat (NFA) för att stödja bakåtreferenser (\1, \k<name>) och godtyckliga lookaround-kontroller ((?=...), (?!...), (?<=...), (?<!...)). Alternativ separerade med | utvärderas från vänster till höger; giriga kvantifierare (*, +, ?, {m,n}) konsumerar så många tecken som möjligt innan de backar steg för steg för att uppfylla efterföljande uttrycksdelar, medan lata kvantifierare (*?, +?, ??, {m,n}?) provar den kortaste expansionen först.

När g (global) eller y (sticky) är aktiverad läser och uppdaterar RegExp.prototype.exec() instansens egenskap lastIndex:

  • Global (g): Söker vid eller efter lastIndex, flyttar fram lastIndex till slutpositionen för varje träff (eller ökar med en Unicode-kodpunkt vid träffar med längden noll) och återställer till 0 när ingen mer träff hittas.
  • Sticky (y): Förankrar matchningen strikt vid lastIndex utan att söka framåt. Om ingen träff börjar exakt vid lastIndex misslyckas matchningen omedelbart och återställer lastIndex till 0, vilket gör y idealisk för att bygga lexikala skannrar utan minneskopiering.

Radbrytningar, UTF-16-surrogatpar och `u`-flaggan

ECMA-262 erkänner exakt fyra kodpunkter som radavslutare: \n (U+000A), \r (U+000D), Line Separator (U+2028) och Paragraph Separator (U+2029). Att aktivera m gör att ^ och $ matchar gränser intill dessa fyra kodpunkter; att aktivera s (dotAll) tillåter att . matchar dem.

Som standard indexeras JavaScript-strängar som sekvenser av 16-bitars UTF-16-kodenheter. Kompletterande Unicode-tecken ovanför U+FFFF (såsom emojis eller matematiska symboler) upptar ett surrogatpar på två enheter (0xD800–0xDBFF högt surrogat följt av 0xDC00–0xDFFF lågt surrogat). Utan u utvärderas /^.$/.test("🚀") till false eftersom "🚀".length är 2. När u aktiveras växlar matchningen till 21-bitars Unicode-skalärvärden, låser upp Unicode-egenskapssekvenser (\p{Letter}, \p{Script=Latin}, \P{Control}) och inaktiverar äldre tillåtande escape-sekvenser enligt Annex B så att ogiltiga escape-tecken ger kompileringsfel direkt.

ECMA-262 `GetSubstitution`-grammatik för ersättningar

Live-ersättningar följer standardtabellen för GetSubstitution:

  • $$: Infogar ett enskilt bokstavligt $-tecken.
  • $&: Infogar hela den matchade delsträngen (match[0]).
  • $': Infogar delsträngen som följer efter det matchade intervallet.
  • $n / $nn: Infogar 1-indexerad numrerad fångstgrupp n (1 till 99).
  • $<name>: Infogar den fångade strängen för (?<name>...), eller en tom sträng "" när den namngivna gruppen inte deltog i den aktuella matchningsgrenen.

Förebyggande av Katastrofal Backtracking (ReDoS)

Regular Expression Denial of Service (ReDoS) uppstår när nästlade eller överlappande kvantifierare – såsom (a+)+$, ([a-zA-Z0-9]+\s?)*$ eller (.*a){12} – matchar identiska delsträngar genom exponentiellt många kombinationer (O(2^n) steg) innan de slutligen misslyckas på ett avslutande tecken. Eftersom ECMA-262 saknar possessiva kvantifierare (++) och atomära grupper ((?>...)), kan du säkra dina mönster genom att:

  1. Ömsesidigt uteslutande teckenklasser: Ersätt giriga .* mellan avgränsare med negerade teckenklasser som [^,\r\n]* så att motorn inte kan korsa avgränsargränser.
  2. Utrullning av avgränsare: Skriv om ^(\w+-?)+$ (tvetydigt när - saknas) till ^\w+(?:-\w+)*$, vilket reducerar värstafallskomplexiteten till strikt linjär O(n).
  3. Atomär emulering med lookahead: Där backtracking in i ett deluttryck måste förbjudas kan du fånga inuti en positiv lookahead och konsumera via en omedelbar bakåtreferens: (?=(\w+))\1.

Regex-testare vs Regex-mönstergenerator: Vilket Verktyg Behöver Du?

Snabbsvar: Använd Regex-testare & Felsökare när du redan har ett mönster och behöver inspektera träffpositioner, felsöka namngivna fångstgrupper, växla ECMAScript-flaggor eller testa strängersättningar med $<name> mot riktig data. Använd Regex-mönstergenerator när du bygger ett nytt uttryck visuellt eller exporterar regex-kod för flera språk.

Även om testning och konstruktion tillhör samma arbetsflöde för reguljära uttryck, löser de olika tekniska problem. Regex-testare & Felsökare är en interaktiv diagnostisk arbetsbänk för att granska hur ett befintligt ECMAScript-mönster beter sig mot komplexa indata från verkligheten. Om du istället behöver bygga ett nytt uttryck från visuella byggstenar, utgå från en RFC-anpassad mall eller exportera färdig kod för Python, Go eller Rust, byt till Regex-generator.

Funktion Regex-testare & Felsökare Regex-generator
Primär uppgift Felsöka träffar, fångstintervall, flaggor och ersättningar på befintliga mönster Konstruera nya mönster visuellt från block eller verifierade RFC-mallar
Startindata Rått regex-uttryck, ECMAScript-flaggor samt flerradig testtext eller loggar Kombinerbara token-block eller utvecklarrecept (UUID, SemVer, IPv4, ISO-8601)
Felsökning av fångstgrupper Fullständiga [start, end)-intervall, $1–$99-platser och (?<name>...)-ordbok Validering av godkända/underkända resultat mot positiva och negativa testfall
Live-strängersättning Realtidsförhandsgranskning av replace / replaceAll med $1, $<name>, $& och $$ Inte fokuserad på mallar för texttransformation
Kodexport för flera språk Utdata för ECMAScript / JavaScript regex-literal och mönster Idiomatiska kodsnuttar för JavaScript, Python (re), Go (regexp) och Rust (regex)
Fokus på motorarkitektur Inbyggd ECMA-262 backtracking-NFA-semantik och ReDoS-detektering Kompatibilitet mellan ECMA-262, Python re och linjärtidsmotorn RE2

Rekommenderat Arbetsflöde

Börja i Regex-generator när du skapar valideringsregler för strukturerade identifierare som semantiska versioner, RFC 9562 UUID:er eller URL-sluggar över tjänster i flera språk. När ett mönster väl har driftsatts i en frontend- eller Node.js-pipeline – eller när ett uttryck oväntat missar ett gränsfall i produktionsloggar – klistrar du in uttrycket och loggutdraget här i Regex-testare & Felsökare för att inspektera teckenintervall per träff, interaktioner med lastIndex-flaggor och ersättningsmallar.

FAQ

Regex-testare & Felsökare FAQ och teknisk guide

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

Varför returnerar ett globalt regex omväxlande true och false med RegExp.prototype.test() i JavaScript?

När den globala (g) eller sticky (y) flaggan är satt på ett RegExp-objekt i JavaScript, uppdaterar anrop till .test() eller .exec() instansens egenskap lastIndex så att den pekar direkt efter den matchade delsträngen. Nästa anrop till .test() återupptar sökningen från lastIndex istället för index 0; när slutet av strängen nås utan ytterligare träff returneras false och lastIndex återställs till 0. För tillståndslös boolesk validering bör du utelämna g-flaggan eller uttryckligen återställa regex.lastIndex = 0.

Vad är skillnaden mellan indexerade fångstgrupper, icke-fångande grupper och namngivna fångstgrupper?

Vanliga parenteser (...) lagrar matchade delsträngar i sekventiella 1-baserade fångstplatser ($1, $2) samt i arrayen som returneras av exec(). Icke-fångande grupper (?:...) grupperar uttrycksdelar för kvantifierare eller alternering utan att spara en delträff eller förskjuta efterföljande $n-index. Namngivna fångstgrupper (?<name>...) fyller både sin sekventiella numrerade plats och match.groups.name (åtkomlig som $<name> i ersättningssträngar), vilket förhindrar att index går sönder när mönstret byggs ut.

När bör jag aktivera Unicode-flaggan (u) i reguljära uttryck för ECMAScript?

Aktivera u så fort du matchar icke-ASCII-text från användare, emojis, kompletterande CJK-tecken eller Unicode-teckenkategorier. Utan u utvärderar JavaScript strängar som 16-bitars UTF-16-kodenheter, vilket gör att . eller negerade teckenklasser som [^x] delar upp 4-bytes surrogatpar ovanför U+FFFF i korrupta halvsurrogat. När du slår på u sker matchningen på fullständiga 21-bitars Unicode-kodpunkter, \p{...}-egenskapssekvenser som \p{Letter} och \p{Number} aktiveras, och strikt syntaxvalidering tillämpas på okända escape-sekvenser.

Hur fungerar ersättningstokens som $&, $1 och $<name> i live-förhandsgranskningen?

Förhandsgranskningen av ersättningar implementerar algoritmen GetSubstitution från ECMA-262 som används av String.prototype.replace() och replaceAll(). $& infogar hela den matchade delsträngen, $1 till $99 infogar motsvarande numrerade fångstgrupp, $<name> infogar texten som fångats av (?<name>...), $' infogar allt efter träffen, dollartecken följt av grav accent infogar allt före träffen och $$ ger ett bokstavligt $-tecken.

Vad orsakar katastrofal backtracking (ReDoS) och hur kan jag skriva om sårbara mönster?

Katastrofal backtracking uppstår i backtracking-baserade NFA-motorer när nästlade eller överlappande kvantifierare – såsom (a+)+b eller ^([a-zA-Z0-9]+\s?)*$ – kan dela upp samma inmatningssekvens på O(2^n) olika sätt innan de misslyckas på ett oväntat avslutande tecken. Eliminera tvetydigheten genom att ersätta giriga .*-intervall med negerade teckenklasser ([^,\r\n]*), rulla ut valfria avgränsare till ^[a-zA-Z0-9]+(?:\s[a-zA-Z0-9]+)*$ och begränsa öppna kvantifierare med uttryckliga gränser ({1,64}). För att bygga RE2-kompatibla mönster med linjär körtid från grunden kan du använda Regex-generator.