Tester i Debugger Regex

Testuj i debuguj wyrażenia regularne JavaScript lokalnie w przeglądarce.

Bez przesyłania plikówBez rejestracjiNatychmiastowe wyniki
Flagi g · i · m · s · u · v · yGrupy przechwytujące i nazwane + zamiana100% Lokalnie • Zero Wysyłania
Testuj wyrażenie regularne
Silnik offline gotowy100% prywatna praca w przeglądarce • Bez wysyłania do chmury
100% prywatności • Zero wysyłania plików na serwer

Dlaczego warto używać darmowego Tester i Debugger Regex od Utiliome?

Stworzone od podstaw dla pełnej prywatności i natychmiastowego działania. Bez subskrypcji, opłat i rejestracji.

Natywna zgodność z silnikiem ECMA-262 RegExp

Wykonuje wyrażenia bezpośrednio na silniku ECMAScript przeglądarki z błyskawicznym przełączaniem flag dla trybu globalnego (g), bez rozróżniania wielkości liter (i), wielowierszowego (m), dotAll (s), Unicode (u) oraz sticky (y).

Inspektor indeksowanych i nazwanych grup przechwytujących

Wyodrębnia indeksowane od zera zakresy jednostek kodowych UTF-16 [start, end), numerowane poddopasowania ($1 do $99) oraz słowniki nazwanych grup przechwytujących ((?<name>...)) dla każdego dopasowania w danych wielowierszowych.

Podgląd podstawień i odwołań wstecznych na żywo

Ewaluuje szablony String.prototype.replace oraz replaceAll w czasie rzeczywistym, obsługując tokeny $1, $<name>, $& (pełne dopasowanie), $' (sufiks po dopasowaniu) oraz sekwencję ucieczki $$ dla znaku dolara.

Ochrona przed ReDoS i pełna prywatność bez wysyłania danych

Wykrywa konstrukcje z zagnieżdżonymi kwantyfikatorami podatne na katastrofalny backtracking, jednocześnie zachowując wrażliwe logi produkcyjne, tokeny autoryzacyjne i dane osobowe wyłącznie w lokalnej pamięci przeglądarki.

Utiliome kontra tradycyjne narzędzia w chmurze

Porównaj nasz lokalny silnik WebAssembly ze starymi narzędziami chmurowymi.

Funkcja Utiliome (Lokalnie w przeglądarce) Tradycyjne konwertery chmurowe
Natywna zgodność z silnikiem ECMA-262 RegExp Wykonuje wyrażenia bezpośrednio na silniku ECMAScript przeglądarki z błyskawicznym przełączaniem flag dla trybu globalnego (g), bez rozróżniania wielkości liter (i), wielowierszowego (m), dotAll (s), Unicode (u) oraz sticky (y). Ograniczone opcje bez zaawansowanej konfiguracji
Inspektor indeksowanych i nazwanych grup przechwytujących Wyodrębnia indeksowane od zera zakresy jednostek kodowych UTF-16 [start, end), numerowane poddopasowania ($1 do $99) oraz słowniki nazwanych grup przechwytujących ((?<name>...)) dla każdego dopasowania w danych wielowierszowych. Wymaga zewnętrznych narzędzi lub ręcznej obróbki
Prywatność i przetwarzanie danych 100% lokalnie w przeglądarce (zero wysyłania na serwer) Przesyła dane na zewnętrzne serwery w chmurze
Cena i wymóg konta 100% za darmo na zawsze bez rejestracji Wymaga rejestracji konta lub płatnej subskrypcji
Jak to działa

Tester i Debugger Regex – instrukcja w 3 prostych krokach

Instalacja oprogramowania nie jest wymagana. Wszystko działa w Twojej przeglądarce.

1

Wprowadź wzorzec i przełącz flagi silnika

Wpisz ciało wyrażenia regularnego bez ukośników otaczających i włącz dokładnie te flagi ECMAScript (g, i, m, s, u, y), z których korzysta docelowe środowisko uruchomieniowe JavaScript lub TypeScript.

2

Wklej dane testowe i przeanalizuj grupy przechwytujące

Wklej ciągi testowe lub wczytaj lokalny plik logów, aby sprawdzić podświetlone granice dopasowań, zakresy indeksów znaków, numerowane sloty przechwytywania oraz mapowania grup (?<name>...).

3

Sprawdź podgląd podstawień i skopiuj wyrażenie

Wprowadź opcjonalny ciąg zastępujący z odwołaniami $1, $<name> lub $&, aby na żywo zweryfikować przekształcony tekst, a następnie skopiuj przetestowany literał regex.

Debugowanie ustrukturyzowanych logów za pomocą nazwanych grup przechwytujących i podstawień na żywo

Szybka odpowiedź: Połącz nazwane grupy przechwytujące ((?<name>...)) z flagami globalną (g) i wielowierszową (m), aby parsować ustrukturyzowane wiersze logów do słowników klucz-wartość, weryfikować dokładne offsety dopasowań UTF-16 i testować przekształcenia ciągów $<name> przed wdrożeniem kodu aplikacji.

Podczas debugowania wyrażeń regularnych na wielowierszowych danych telemetrycznych lub logach dostępowych drobne błędy w kotwicach lub kwantyfikatorach często powodują cichy brak dopasowań albo przesunięcie numerowanych grup. Rozważmy dwa ustrukturyzowane wiersze logów aplikacji zawierające znaczniki czasu ISO-8601, poziomy istotności, identyfikatory usług, 16-znakowe szesnastkowe identyfikatory trace ID, kody statusu HTTP oraz zmiennoprzecinkowe czasy opóźnień:

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

Aby deterministycznie sparsować każdy wiersz bez podatnego na błędy indeksowania pozycyjnego tablicy, powiąż każde pole z nazwaną grupą przechwytującą ECMAScript ((?<name>...)), opakuj opcjonalną część ułamkową milisekund w grupę nieprzechwytującą ((?:...)) i włącz zarówno flagę g (iteracja globalna), jak i m (kotwice ^ oraz $ dla każdego wiersza):

^(?<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+)?)$

Bez flagi m znaki ^ i $ kotwiczą się wyłącznie do indeksu 0 oraz końca całego bufora, przez co wyrażenie przestaje pasować, gdy tylko rekordy zostaną rozdzielone znakiem nowej linii (\n). Przy aktywnych flagach gm debugger grup przechwytujących przekształca każdą iterację dopasowania zarówno w indeksowane od 1 poddopasowania pozycyjne, jak i ustrukturyzowany obiekt groups:

{
  "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"
  }
}

Po zweryfikowaniu granic przechwytywania możesz przetestować formatowanie String.prototype.replaceAll bezpośrednio w panelu podstawień. Podanie szablonu [$<level>] $<service>: HTTP $<status> ($<ms>ms, trace=$<trace>) natychmiast generuje znormalizowany wynik:

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

Semantyka silnika ECMA-262 RegExp, mechanika flag i katastrofalny backtracking

Szybka odpowiedź: Wyrażenia regularne w JavaScript wykonują się na automacie NFA z nawrotami (backtracking) zdefiniowanym w specyfikacji ECMA-262 sekcja 22.2, operując na 16-bitowych jednostkach kodowych UTF-16, chyba że flaga u włączy pełne dopasowywanie skalarów Unicode. Unikanie niejednoznacznych zagnieżdżonych kwantyfikatorów zapobiega wykładniczym przestojom O(2^n) typu ReDoS.

Wykonywanie na automacie NFA z nawrotami i stanowa właściwość `lastIndex`

W przeciwieństwie do silników opartych na czystych deterministycznych automatach skończonych (DFA), silniki ECMAScript (V8 Irregexp, JavaScriptCore Yarr, SpiderMonkey) implementują niedeterministyczny automat skończony (NFA) z nawrotami, aby obsługiwać odwołania wsteczne (\1, \k<name>) oraz dowolne asercje lookaround ((?=...), (?!...), (?<=...), (?<!...)). Alternatywy rozdzielone znakiem | są ewaluowane od lewej do prawej; kwantyfikatory zachłanne (*, +, ?, {m,n}) pochłaniają jak najwięcej znaków, zanim zaczną cofać się krok po kroku w celu spełnienia dalszych tokenów, natomiast kwantyfikatory leniwe (*?, +?, ??, {m,n}?) najpierw próbują najkrótszego rozwinięcia.

Gdy ustawiona jest flaga g (globalna) lub y (sticky), metoda RegExp.prototype.exec() odczytuje i modyfikuje właściwość lastIndex danej instancji:

  • Globalna (g): Wyszukuje na pozycji lastIndex lub za nią, przesuwając lastIndex na offset końcowy każdego dopasowania (lub zwiększając o jeden punkt kodowy Unicode przy dopasowaniach o zerowej długości) oraz resetując go do 0 w przypadku braku dopasowania.
  • Sticky (y): Kotwiczy dopasowanie ściśle na pozycji lastIndex bez skanowania w przód. Jeśli na pozycji lastIndex nie rozpoczyna się żadne dopasowanie, operacja natychmiast kończy się niepowodzeniem i resetuje lastIndex do 0, co czyni flagę y idealnym rozwiązaniem do budowy skanerów leksykalnych typu zero-copy.

Terminatory wiersza, pary surogatowe UTF-16 i flaga `u`

Specyfikacja ECMA-262 rozpoznaje dokładnie cztery punkty kodowe terminatorów wiersza: \n (U+000A), \r (U+000D), separator wiersza (U+2028) oraz separator akapitu (U+2029). Włączenie flagi m sprawia, że ^ oraz $ dopasowują granice sąsiadujące z tymi czterema punktami kodowymi; włączenie flagi s (dotAll) pozwala kropce . dopasowywać również te znaki.

Domyślnie ciągi znaków w JavaScript są indeksowane jako sekwencje 16-bitowych jednostek kodowych UTF-16. Dodatkowe znaki Unicode powyżej U+FFFF (takie jak emoji czy symbole matematyczne) zajmują dwujednostkową parę surogatową (wysoki surogat 0xD800–0xDBFF, po którym następuje niski surogat 0xDC00–0xDFFF). Bez flagi u wywołanie /^.$/.test("🚀") zwraca false, ponieważ "🚀".length wynosi 2. Włączenie flagi u przełącza dopasowywanie na 21-bitowe wartości skalarne Unicode, odblokowuje sekwencje właściwości Unicode (\p{Letter}, \p{Script=Latin}, \P{Control}) oraz wyłącza przestarzałe, permisywne sekwencje ucieczki z Annex B, dzięki czemu nieprawidłowe sekwencje zgłaszają błąd już na etapie kompilacji.

Gramatyka podstawień `GetSubstitution` w ECMA-262

Zamiana tekstu na żywo przebiega zgodnie ze standardową tabelą GetSubstitution:

  • $$: Wstawia pojedynczy dosłowny znak $.
  • $&: Wstawia cały dopasowany podciąg (match[0]).
  • $': Wstawia podciąg znajdujący się za dopasowanym zakresem.
  • $n / $nn: Wstawia indeksowaną od 1 grupę przechwytującą o numerze n (od 1 do 99).
  • $<name>: Wstawia przechwycony ciąg dla grupy (?<name>...) lub pusty ciąg "", gdy nazwana grupa nie brała udziału w bieżącej gałęzi dopasowania.

Zapobieganie katastrofalnemu backtrackingowi (ReDoS)

Zjawisko Regular Expression Denial of Service (ReDoS) powstaje, gdy zagnieżdżone lub nakładające się kwantyfikatory — takie jak (a+)+$, ([a-zA-Z0-9]+\s?)*$ czy (.*a){12} — dopasowują identyczne podciągi poprzez wykładniczo wiele podziałów (O(2^n) kroków), zanim poniosą porażkę na końcowym znaku. Ponieważ standard ECMA-262 nie posiada kwantyfikatorów zachłannych bez nawrotów (++) ani grup atomowych ((?>...)), wzorce należy zabezpieczać poprzez:

  1. Wzajemnie wykluczające się zbiory znaków: Zastąp zachłanne .* pomiędzy ogranicznikami zanegowanymi klasami znaków, np. [^,\r\n]*, aby silnik nie mógł przekraczać granic ograniczników.
  2. Rozwijanie pętli z ogranicznikami (Delimiter Unrolling): Przepisz ^(\w+-?)+$ (niejednoznaczne przy braku znaku -) do postaci ^\w+(?:-\w+)*$, co redukuje złożoność w najgorszym przypadku do ściśle liniowej O(n).
  3. Emulację grup atomowych za pomocą lookahead: Tam, gdzie cofanie się do podwyrażenia musi być zablokowane, przechwyć ciąg wewnątrz pozytywnej asercji lookahead i skonsumuj go natychmiastowym odwołaniem wstecznym: (?=(\w+))\1.

Tester i Debugger Regex a Generator Regex: Którego narzędzia potrzebujesz?

Szybka odpowiedź: Użyj narzędzia Tester i Debugger Regex, gdy masz już gotowy wzorzec i chcesz sprawdzić offsety dopasowań, zdebugować nazwane grupy przechwytujące, przełączyć flagi ECMAScript lub przetestować podstawienia ciągów $<name> na rzeczywistych danych. Wybierz Generator Regex, gdy budujesz nowe wyrażenie wizualnie lub eksportujesz kod regex dla wielu języków.

Choć testowanie i tworzenie wyrażeń należą do tego samego przepływu pracy z wyrażeniami regularnymi, rozwiązują odmienne problemy inżynieryjne. Tester i Debugger Regex to interaktywne środowisko diagnostyczne do analizowania, jak istniejący wzorzec ECMAScript zachowuje się na złożonych, rzeczywistych danych wejściowych. Jeśli natomiast musisz zbudować nowe wyrażenie z wizualnych bloków konstrukcyjnych, zacząć od gotowego szablonu zgodnego z RFC lub wyeksportować odpowiednio wyescapowany kod dla języków Python, Go czy Rust, przejdź do narzędzia Generator Regex.

Funkcjonalność Tester i Debugger Regex Generator Regex
Główne zadanie inżynieryjne Debugowanie dopasowań, zakresów grup, flag i podstawień na istniejących wzorcach Wizualne konstruowanie nowych wzorców z bloków lub sprawdzonych szablonów RFC
Dane wejściowe na starcie Surowe wyrażenie regex, flagi ECMAScript oraz wielowierszowy tekst testowy lub logi Komponowalne bloki tokenów lub gotowe receptury (UUID, SemVer, IPv4, ISO-8601)
Debugowanie grup przechwytujących Pełne zakresy offsetów [start, end), sloty tablicy $1–$99 oraz słownik (?<name>...) Walidacja typu pass/fail na pozytywnych i negatywnych przypadkach testowych
Podstawianie ciągów na żywo Podgląd replace / replaceAll w czasie rzeczywistym z obsługą $1, $<name>, $& oraz $$ Brak skupienia na szablonach transformacji tekstu
Eksport kodu dla wielu języków Literał regex oraz czysty wzorzec dla ECMAScript / JavaScript Idiomatyczne snippety kodu dla języków JavaScript, Python (re), Go (regexp) oraz Rust (regex)
Architektura silnika Natywna semantyka NFA z nawrotami ECMA-262 oraz wykrywanie podatności ReDoS Przenośność między silnikami ECMA-262, Python re oraz liniowym RE2

Zalecany przepływ pracy

Rozpocznij pracę w narzędziu Generator Regex podczas przygotowywania reguł walidacji dla ustrukturyzowanych identyfikatorów, takich jak wersje semantyczne, identyfikatory UUID zgodne z RFC 9562 czy slugi URL w wielojęzycznych mikroserwisach. Gdy wzorzec zostanie wdrożony we frontendzie lub potoku Node.js — albo gdy wyrażenie nieoczekiwanie pominie przypadek brzegowy w logach produkcyjnych — wklej wyrażenie i surową próbkę logów tutaj, w Testerze i Debuggerze Regex, aby dokładnie zbadać zakresy znaków dla każdego dopasowania, interakcje flag z właściwością lastIndex oraz szablony podstawień.

FAQ

Tester i Debugger Regex – FAQ i przewodnik techniczny

Wszystko, co musisz wiedzieć o darmowym narzędziu online tester wyrażeń regularnych online od Utiliome.

Dlaczego globalne wyrażenie regularne zwraca na przemian true i false w metodzie RegExp.prototype.test() w JavaScript?

Gdy na obiekcie RegExp w JavaScript ustawiona jest flaga globalna (g) lub sticky (y), wywołanie metody .test() lub .exec() modyfikuje właściwość lastIndex tej instancji, ustawiając ją bezpośrednio za dopasowanym podciągiem. Kolejne wywołanie .test() wznawia skanowanie od pozycji lastIndex, a nie od indeksu 0; gdy dotrze do końca ciągu bez kolejnego dopasowania, zwraca false i resetuje lastIndex z powrotem do 0. W przypadku bezstanowej walidacji logicznej pomiń flagę g lub jawnie zresetuj regex.lastIndex = 0.

Jaka jest różnica między indeksowanymi grupami przechwytującymi, grupami nieprzechwytującymi a nazwanymi grupami przechwytującymi?

Standardowe nawiasy (...) zapisują dopasowane podciągi w kolejnych, indeksowanych od 1 slotach przechwytywania ($1, $2) oraz w tablicy zwracanej przez metodę exec(). Grupy nieprzechwytujące (?:...) grupują tokeny na potrzeby kwantyfikatorów lub alternatyw bez rejestrowania poddopasowania i bez przesuwania dalszych indeksów $n. Nazwane grupy przechwytujące (?<name>...) wypełniają zarówno swój kolejny numerowany slot, jak i obiekt match.groups.name (dostępny jako $<name> w ciągach zastępujących), co zapobiega psuciu indeksów podczas rozwoju wzorca.

Kiedy należy włączyć flagę Unicode (u) w wyrażeniach regularnych ECMAScript?

Włączaj flagę u zawsze, gdy dopasowujesz tekst użytkownika spoza zestawu ASCII, znaki emoji, dodatkowe ideogramy CJK lub kategorie znaków Unicode. Bez flagi u JavaScript interpretuje ciągi jako 16-bitowe jednostki kodowe UTF-16, co sprawia, że kropka . lub zanegowane klasy znaków takie jak [^x] rozdzielają 4-bajtowe pary surogatowe powyżej U+FFFF na uszkodzone pół-surogaty. Włączenie flagi u przełącza dopasowywanie na pełne 21-bitowe punkty kodowe Unicode, udostępnia sekwencje właściwości \p{...}, takie jak \p{Letter} oraz \p{Number}, i wymusza ścisłą walidację składni dla nierozpoznanych sekwencji ucieczki.

Jak działają tokeny zastępowania takie jak $&, $1 oraz $<name> w podglądzie podstawień na żywo?

Podgląd podstawień implementuje algorytm GetSubstitution ze specyfikacji ECMA-262, wykorzystywany przez metody String.prototype.replace() oraz replaceAll(). Token $& wstawia cały dopasowany podciąg, tokeny od $1 do $99 wstawiają odpowiednią numerowaną grupę przechwytującą, $<name> wstawia tekst przechwycony przez grupę (?<name>...), $' wstawia wszystko po dopasowaniu, znak dolara z grawisem wstawia wszystko przed dopasowaniem, natomiast $$ generuje pojedynczy, dosłowny znak $.

Co powoduje katastrofalny backtracking (ReDoS) i jak przepisać podatne wzorce?

Katastrofalny backtracking występuje w silnikach NFA z nawrotami, gdy zagnieżdżone lub nakładające się kwantyfikatory — takie jak (a+)+b czy ^([a-zA-Z0-9]+\s?)*$ — mogą podzielić tę samą sekwencję wejściową na O(2^n) sposobów, zanim poniosą porażkę na nieoczekiwanym znaku końcowym. Wyeliminuj niejednoznaczność, zastępując zachłanne zakresy .* zanegowanymi klasami znaków ([^,\r\n]*), rozwijając opcjonalne separatory do postaci ^[a-zA-Z0-9]+(?:\s[a-zA-Z0-9]+)*$ oraz ograniczając otwarte kwantyfikatory jawnymi limitami ({1,64}). Aby od podstaw budować wzorce o liniowym czasie wykonania kompatybilne z silnikiem RE2, skorzystaj z narzędzia Generator Regex.