Skip to content

Darmowy Regex Tester — dopasuj i debuguj wzorce online

Testuj wzorce regex natychmiast względem dowolnego tekstu. Podświetlanie dopasowań na żywo, grupy przechwytujące, podgląd zamiany, podział oraz wyjaśniacz wzorca. Regex w wariancie JavaScript, w 100% prywatnie, bez rejestracji.

Bez śledzenia Działa w przeglądarce Bezpłatne
Całe testowanie odbywa się lokalnie w Twojej przeglądarce. Twój wzorzec i tekst nigdy nie opuszczają tego urządzenia.
Flagi
    Podświetlone dopasowania
    Dopasowania i grupy przechwytujące
    Sprawdzono pod kątem wierności ECMA-262, poprawności grup przechwytujących (z flagą /d i bez), parytetu szablonu zamiany ze String.prototype.replace, odporności na ReDoS przez budżetowanie zegara ściennego oraz dostępności (role ARIA, ogłaszanie dopasowań dla czytników ekranu, obsługa RTL/LTR). — Zespół narzędzi tekstowych Go Tools · May 21, 2026

    Czym jest tester regex?

    Tester regex (tester wyrażeń regularnych) to narzędzie, które pozwala napisać wzorzec regex, wkleić kawałek tekstu testowego i zobaczyć dokładnie, co wzorzec dopasowuje — z grupami przechwytującymi, podglądem zamiany i rozbiorem flag — bez rekompilowania kodu czy uruchamiania skryptu. Dla deweloperów skraca to pętlę z minut do milisekund: dostosuj wzorzec, obserwuj przesuwające się podświetlenia, wyślij regex z pewnością.

    Wyrażenie regularne to kompaktowy język do opisywania wzorców tekstu. `\d+` dopasowuje jedną lub więcej cyfr. `[A-Za-z_]\w*` dopasowuje typowy identyfikator. `(?\d{4})-(?\d{2})-(?\d{2})` dopasowuje datę ISO i nazywa każdą część. Wyrażenia regularne to kręgosłup wyszukiwania i zamiany w każdym edytorze kodu, walidacji w każdym formularzu, parsowania logów w każdym stosie obserwowalności oraz `grep`, `sed` i `awk` — narzędzi uniksowych, na których działa pół internetu. Są też notorycznie trudne do napisania poprawnie: kwantyfikator o jeden za daleko lub brakujący escape może dopasować niewłaściwy podciąg, w ogóle przegapić dopasowanie lub — w najgorszym przypadku — wywołać katastrofalne nawroty, które biorą rdzeń CPU jako zakładnika. Dobry tester regex wychwytuje każdy z tych trybów awarii, zanim trafią do produkcji.

    Ten tester uruchamia natywny silnik RegExp ECMA-262, który wysyłany jest w każdej nowoczesnej przeglądarce — ten sam silnik, do którego dzwonisz z JavaScript, TypeScript, Node.js, Deno czy Bun. Oznacza to: grupy przechwytujące (numerowane i nazwane z `(?...)`), asercje lookahead i lookbehind (`(?=...)`, `(?!...)`, `(?<=...)`, `(?

    Co tester wyciąga na wierzch poza surowymi dopasowaniami: panel Dopasowania i grupy przechwytujące wymienia każde dopasowanie z jego przesunięciami [start, end) i wartością każdej grupy przechwytującej — te same informacje, które dostałbyś z `String.prototype.matchAll` z flagą /d, ale ułożone do wizualnego skanowania. Zakładka Zamień pokazuje podgląd podstawienia na żywo, obsługując pełny alfabet szablonów $1 / $& / $` / $' / $$ / $ — dokładnie to, co przyjmuje String.replace w JavaScript. Zakładka Podziel stosuje String.split z regexem i pokazuje każdą część. Zakładka Wyjaśnij tokenizuje wzorzec i adnotuje każdy fragment prostym opisem, przydatna do code review, nauczania i przenoszenia między dialektami.

    Dla prywatności: każda operacja jest lokalna. Twój wzorzec i tekst testowy nigdy nie opuszczają strony — nie są logowane, nie są wysyłane do usługi analitycznej, nie są przechowywane na dysku. Tylko Twoje preferencje UI (aktywna zakładka i flagi, które zwykle masz włączone) zapisują się do localStorage. To czyni narzędzie bezpiecznym dla zanonimizowanych próbek logów, wzorców firmowych, wewnętrznej konfiguracji i wzorców zawierających wskazówki o schemacie Twoich danych. W porównaniu z testerami opartymi na serwerze, jak regex101, historia prywatności i opóźnień jest ściśle lepsza; kompromisem jest obsługa pojedynczej odmiany (tylko JavaScript).

    Jeśli jesteś nowy w regexie, rozwijane menu Popularne wzorce wysyła sprawdzone w boju startery: adres e-mail, URL, IPv4, UUID, hex color, data ISO, amerykański numer telefonu i wzorzec do przycinania końcowych białych znaków. Załaduj jeden, obserwuj dopasowania względem dostarczonej próbki tekstu, a następnie mutuj wzorzec po jednym znaku, aby wyczuć, jak reaguje silnik. Sparuj to z narzędziem Text Diff, gdy chcesz porównać przed/po czyszczenia opartego na regex, z JSON Formatter, gdy Twoje wejście lub oczekiwane wyjście to JSON, lub z koderem URL, gdy ciągi, które dopasowujesz, są zakodowane URL-em.

    // The pattern you build in this tester drops straight into JavaScript.
// Example: extract every ISO date from a string with named groups.

const pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g;
const text = 'shipped 2026-05-21, scheduled 2026-06-30';

for (const m of text.matchAll(pattern)) {
  console.log(m.groups.year, m.groups.month, m.groups.day);
  // → 2026 05 21
  // → 2026 06 30
}

// Same regex, used in a replace with $<name> templates:
text.replace(pattern, '$<day>/$<month>/$<year>');
// → 'shipped 21/05/2026, scheduled 30/06/2026'

// With the /d flag, every match carries [start, end] indices
// per capture group — the Matches panel uses this to paint offsets.
const p2 = /(?<year>\d{4})-(?<month>\d{2})/gd;
const m = [...text.matchAll(p2)][0];
m.indices.groups.year; // [8, 12]

    Kluczowe funkcje

    Podświetlanie dopasowań na żywo

    Każde dopasowanie w tekście testowym zapala się w chwili, gdy Twój wzorzec się parsuje. Naprzemienne kolory ułatwiają wizualne liczenie sąsiednich dopasowań, a odznaka liczby nad wynikiem podaje dokładną sumę — bez przycisku Uruchom, bez opóźnienia debounce powyżej 200 ms.

    Boczny panel grup przechwytujących

    Panel Dopasowania i grupy przechwytujące po prawej wymienia każde dopasowanie jako kartę z przesunięciami [start, end), pełnym tekstem dopasowania i każdą pozycyjną oraz nazwaną grupą przechwytującą wewnątrz. Grupy nazwane oznaczają się jako $, więc czytasz dane w ten sam sposób, w jaki będziesz je konsumować w kodzie.

    Podgląd zamiany na żywo z $1 / $& / $

    Przełącz się na zakładkę Zamień, aby zobaczyć podstawienie stosowane w czasie rzeczywistym. Działa pełny alfabet zamiany ECMAScript: $1..$N dla pozycyjnych, $ dla nazwanych, $& dla całego dopasowania, $` i $' dla prefiksu/sufiksu, $$ dla dosłownego dolara. Panele wejścia i wyjścia obok siebie z kopiowaniem jednym kliknięciem.

    Podział z granicami regex

    Zakładka Podziel wywołuje String.prototype.split z Twoim regexem i pokazuje każdą część jako numerowaną listę. Puste części renderowane są glifem ⏎, dzięki czemu widzisz, jak silnik obsłużył sąsiednie separatory — przydatne do debugowania czyszczenia wejścia w stylu CSV.

    Wyjaśniacz wzorca (token po tokenie)

    Zakładka Wyjaśnij tokenizuje Twój wzorzec na chipy kolorowane według klasy (escape / kwantyfikator / klasa znaków / grupa / kotwica / alternatywa) i adnotuje każdy chip jednolinijkowym opisem. Przeczytaj sobie własny regex z powrotem przed wysłaniem; użyj do code review lub nauczania.

    Bezpieczny dla ReDoS (timeout zegara ściennego)

    Każde wywołanie dopasowania opakowane jest w budżet 250 milisekund. Klasyczne kształty katastrofalnych nawrotów, jak `(a+)+`, `(a|aa)+b` i głęboko zagnieżdżone kwantyfikatory, przerywają się czysto z ostrzeżeniem Wzorzec przekroczył limit czasu — strona pozostaje responsywna zamiast blokować kartę. Wykrywanie bez sandboxa po stronie serwera.

    Biblioteka popularnych wzorców

    Sprawdzone w boju startery dla ośmiu wzorców, po które deweloperzy sięgają najczęściej: e-mail, URL, IPv4, UUID v4, hex color, data ISO, amerykański numer telefonu i przycinanie końcowych białych znaków. Każdy ładuje się z pasującą próbką, więc widzisz regex w działaniu, zanim go dostosujesz.

    Udostępnianie permalinkami (bez przesyłania)

    Kopiuj link koduje wzorzec + flagi + przykładowy tekst do hasha URL (#p=…&f=gim&t=…). Przeglądarki nigdy nie przesyłają fragmentów URL w zapytaniach, więc udostępniony link odtwarza Twój stan na komputerze odbiorcy bez dotykania serwerów go-tools.org. Samowystarczalne, przyjazne audytowi.

    W 100% prywatnie, tylko w przeglądarce

    Twój regex i tekst testowy nigdy nie opuszczają Twojego urządzenia. Bez zapytań sieciowych, bez logowania, bez analityki tego, co piszesz. Zweryfikuj w DevTools → Network: zero zapytań, gdy piszesz. Bezpieczne dla wzorców firmowych, zanonimizowanych logów i każdego tekstu, którego nie wkleiłbyś do regex101.

    Przepracowane przykłady

    Wyodrębnij każdy adres e-mail z akapitu

    [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}
    /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g

    Wklej wzorzec z włączoną flagą /g, wrzuć akapit do tekstu testowego, a każdy e-mail rozświetli się w widoku z podświetleniem. Panel Dopasowania i grupy przechwytujące po prawej stronie wymienia każdy adres z jego przesunięciami [start, end) — przydatne, gdy ten sam regex przepuszczasz do grep, sed lub edytora kodu.

    Przechwyć części daty z nazwanymi grupami

    (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})
    /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g

    Nazwane grupy ECMA-262 pojawiają się w prawym panelu jako $, $, $. Przełącz się na zakładkę Zamień i wypróbuj $/$/$, aby przeformatować daty ISO na DMY w jednym przebiegu — ta sama sztuczka działa w dowolnym nowoczesnym wywołaniu replace w JS.

    Znajdź/zamień z odwołaniami wstecznymi $1

    (\w+) (\w+)
    Zamiana: $2, $1   →   Jack Doe → Doe, Jack

    Dwie nienazwane grupy przechwytujące, szablon zamiany $2, $1, a zakładka Zamień daje podgląd na żywo. $&, $`, $', $$ i $ są wszystkie obsługiwane — dokładnie alfabet podstawień ze specyfikacji ECMAScript, więc to, co skopiujesz, działa bez zmian w dowolnym silniku JS.

    Usuń końcowe białe znaki linia po linii

    [ \t]+$
    /[ \t]+$/gm

    Połącz flagi /g (global) i /m (multiline), aby $ zakotwiczał się na końcu każdej linii, a nie tylko na końcu wejścia. Zakładka Zamień z pustą zamianą pokazuje czysty diff: końcowe tabulatory i spacje znikają, proza zostaje. Ten sam regex z wyłączoną flagą /s (dotAll) sprawia, że . nie przekracza nowych linii.

    Wykryj katastrofalne nawroty i przetrwaj je

    (a+)+b
    Tekst testowy: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac

    Zagnieżdżone kwantyfikatory + tworzą klasyczny wzorzec ReDoS. W naiwnym testerze powoduje to zawieszenie karty. Tutaj zabezpieczenie zegara ściennego uruchamia się po 250 ms, pojawia się baner Wzorzec przekroczył limit czasu, a strona pozostaje responsywna. Zakotwicz wzorzec, przełącz się na alternatywę bez nakładania lub użyj idiomów atomic-like — i przetestuj ponownie.

    Podziel linię w stylu CSV po mieszanych separatorach

    [,;|]\s*
    alpha, beta; gamma | delta → ["alpha", "beta", "gamma", "delta"]

    Przełącz się na zakładkę Podziel. Każdy przecinek, średnik lub potok (a po nim opcjonalny biały znak) staje się granicą części. Przydatne do czyszczenia wklejanych list tagów, normalizowania wejścia użytkownika lub wstępnego przetwarzania pól logów przed prawdziwym parserem CSV — zobacz CSV na JSON, gdy dane naprawdę są zgodne z RFC 4180.

    Jak używać testera regex

    1. 1

      Wpisz wzorzec między ukośnikami

      Wrzuć dowolne wyrażenie regularne ECMA-262 do pola /…/. Złe wzorce podświetlają się na czerwono z komunikatem parsera; poprawne wzorce przechodzą do dopasowania na żywo.

    2. 2

      Przełącz potrzebne flagi

      g (global), i (case-insensitive), m (multiline), s (dotAll), u (unicode), y (sticky), d (indices). Każdy chip zapala się, gdy jest włączony; odczyt po prawej od wzorca pokazuje kanoniczny literał.

    3. 3

      Wklej tekst testowy

      Dopasowania podświetlają się naprzemiennymi kolorami w trakcie pisania. Panel Dopasowania i grupy przechwytujące po prawej wymienia każde dopasowanie z przesunięciami [start, end) i wartością każdej grupy przechwytującej (grupy nazwane oznaczone $).

    4. 4

      Przełączaj zakładki dla Zamień, Podziel lub Wyjaśnij

      Zamień podgląda szablon podstawienia obok wejścia. Podziel kroi na każdej granicy dopasowania. Wyjaśnij rozkłada wzorzec token po tokenie z prostym opisem każdego elementu.

    5. 5

      Skopiuj literał lub udostępnij permalink

      Kopiuj /pattern/flags umieszcza kanoniczny literał regex w schowku do bezpośredniego użycia w JavaScript / TypeScript / Node. Kopiuj link koduje pełny stan do hasha URL (bez przesyłania), więc kolega może odtworzyć go lokalnie.

    Częste błędy w regex

    Zapomniałeś flagi /g i dostałeś tylko jedno dopasowanie

    Bez /g (lub /y) silnik zatrzymuje się po pierwszym dopasowaniu. Metody match, matchAll, replace i split wszystkie zachowują się różnie wokół flagi global. Przełącz /g i uruchom ponownie; liczba nad wynikami skacze z 1 do N.

    ✗ Niepoprawne 
    Wzorzec: /\d+/  →  „1 22 333” daje tylko [„1”]
    ✓ Poprawne 
    Wzorzec: /\d+/g  →  „1 22 333” daje [„1”, „22”, „333”]

    Zachłanny kwantyfikator skonsumował za dużo

    `.+` konsumuje tak dużo, jak to możliwe, więc `<.+>` na „ and ” przechwytuje „ and ”, a nie „”. Użyj kwantyfikatorów leniwych (`.+?`), bardziej restrykcyjnych klas znaków (`[^>]+`) lub zakotwicz lookaroundami.

    ✗ Niepoprawne 
    Wzorzec: /<.+>/  →  dopasowuje „<a> and <b>”
    ✓ Poprawne 
    Wzorzec: /<[^>]+>/  →  dopasowuje „<a>” i „<b>” osobno

    Katastrofalne nawroty z zagnieżdżonych kwantyfikatorów

    `(a+)+b` na długim niepowodzeniowym stringu wybucha wykładniczo. Baner Wzorzec przekroczył limit czasu uruchamia się po 250 ms; przepisz, aby usunąć zagnieżdżenie: `a+b` wykonuje to samo zadanie w czasie liniowym. Symulacja grupy atomic `(?=(a+))\1b` to inna opcja.

    ✗ Niepoprawne 
    Wzorzec: /(a+)+b/  na „aaaaaaaaaaaaaaaaaaaaac”  →  timeout
    ✓ Poprawne 
    Wzorzec: /a+b/  na tym samym wejściu  →  natychmiastowe „brak dopasowania”

    Kotwice $ i ^ nie zachowują się jak Pythonowe \A i \Z

    W JavaScript `^` i `$` oznaczają początek-linii / koniec-linii TYLKO gdy /m jest włączone; w przeciwnym razie oznaczają początek-stringu / koniec-stringu. Pythonowe `\A` i `\Z` (które zawsze oznaczają granice stringu) nie istnieją w JS. Przełącz /m zgodnie z potrzebą.

    ✗ Niepoprawne 
    Wzorzec: /^Error/  na wieloliniowym logu bez /m  →  dopasowuje tylko pierwszą linię
    ✓ Poprawne 
    Wzorzec: /^Error/m  na tym samym wejściu  →  dopasowuje każdą linię zaczynającą się od Error

    Użyłeś $1 w stringu, ale wywołałeś replace z funkcją

    `text.replace(re, '$1')` rozwija odwołanie wsteczne. `text.replace(re, () => '$1')` przekazuje dosłowny string „$1”, ponieważ funkcje nie widzą tokenów szablonu. Wewnątrz funkcji grupy przechwytujące przychodzą jako argumenty pozycyjne.

    ✗ Niepoprawne 
    text.replace(/(\w+)/, m => '$1')  →  daje dosłowne „$1”
    ✓ Poprawne 
    text.replace(/(\w+)/, (_, g1) => g1.toUpperCase())  →  używa przechwytu

    Znaki Unicode nie dopasowują się z \w lub .

    Domyślne `\w` to `[A-Za-z0-9_]`. Aby dopasować każdą literę w każdym piśmie, włącz /u i przełącz się na `\p{Letter}` (`\p{L}`). Kropka również zatrzymuje się na nowych liniach domyślnie — użyj /s (dotAll), gdy chcesz prawdziwego dowolnego-znaku.

    ✗ Niepoprawne 
    Wzorzec: /\w+/  dopasowuje „hello”, ale nie „héllo” ani „你好”
    ✓ Poprawne 
    Wzorzec: /\p{Letter}+/u  dopasowuje wszystkie trzy

    Wkleiłeś wzorzec PCRE; dostałeś SyntaxError

    JavaScript nie obsługuje grup atomic `(?>...)`, kwantyfikatorów zaborczych `a++`, modyfikatorów inline `(?i)`, warunków `(?(1)yes|no)` ani `\A` / `\Z`. Błąd parsera nazywa naruszający konstrukt — przepisz na ekwiwalent obsługiwany przez JS (symulacja lookaroundem, osobne przełączenie flagi, alternatywa).

    ✗ Niepoprawne 
    Wzorzec: (?i)foo  →  SyntaxError: invalid group
    ✓ Poprawne 
    Wzorzec: foo z włączoną flagą /i  →  ten sam efekt

    Kto używa tego narzędzia

    Waliduj dane wejściowe formularzy przed wysyłką
    Potwierdź, że Twój regex e-maila / telefonu / kodu pocztowego / nazwy użytkownika dopasowuje to, czego oczekujesz — i odrzuca to, czego nie chcesz — w przypadkach granicznych (nazwy Unicode, aliasy z plusem, formaty międzynarodowe), zanim walidacja trafi do produkcji i odbije prawdziwych użytkowników.
    Wyodrębniaj dane z logów i konfiguracji
    Zbuduj wzorzec, który wyciąga ID zapytań, kody statusu, opóźnienia lub linie stack trace z dowolnego fragmentu logu. Nazwane grupy czynią dane samoopisującymi; panel Dopasowania pokazuje przesunięcia, więc możesz potem przepuścić ten sam regex do `rg --replace` lub `grep -oE`.
    Znajdź/zamień w całej bazie kodu
    Naszkicuj wzorzec refaktoryzacji (np. `(\w+)\.apply\(null,\s*\[(.*?)\]\)` → `$1($2)`) tutaj, podglądnij podstawienie względem reprezentatywnych fragmentów, a następnie wklej zwalidowany regex do globalnego znajdź/zamień w edytorze z pewnością.
    Sanity-check wzorca znalezionego online
    Wkleiłeś regex ze StackOverflow lub bloga? Wrzuć go do zakładki Wyjaśnij — każdy token zostaje zaadnotowany prostym opisem. Wychwytuje subtelne problemy (`.+?` tam, gdzie chciałeś `.+`, brakujące kotwice `^`/`$`, przypadkowo zachłanne kwantyfikatory), zanim regex wyląduje w Twoim kodzie.
    Naucz koleżankę regex
    Otwórz zakładkę Wyjaśnij na działającym wzorcu i przejdź przez niego token po tokenie. Kodowanie kolorami (escape / kwantyfikator / klasa znaków / grupa / kotwica / alternatywa) pozwala uczącemu się zobaczyć strukturalny kształt regex, a nie tylko znaki.
    Przenieś wzorzec między językami
    Masz regex Python lub PCRE, którego potrzebujesz użyć w JavaScript? Wklej tutaj. Jeśli się parsuje, wyjaśniacz pokaże Ci semantykę ekwiwalentu JS; jeśli nie, błąd parsera nazywa naruszający konstrukt (grupy atomic, kwantyfikatory zaborcze, inline `(?i)`), więc wiesz dokładnie, co przepisać.
    Debuguj wolny regex produkcyjny
    Jeśli serwerowy regex jest podejrzewany o katastrofalne nawroty, wklej go do tego testera z próbką wejścia. Zabezpieczenie zegara ściennego 250 ms uruchamia się w przypadkach patologicznych, dając natychmiastową diagnozę przed sięgnięciem po narzędzia profilujące — a wyjaśniacz wskazuje na zagnieżdżone kwantyfikatory jako główną przyczynę.

    Notatki o silniku i algorytmie

    Silnik RegExp ECMA-262 (natywny przeglądarki)
    Używa `new RegExp(pattern, flags)` i silnika wysyłanego z V8 / JavaScriptCore / SpiderMonkey — tej samej semantyki regex, którą dostajesz w JavaScript wszędzie. Wzorce, które tu się walidują, działają bez zmian w Node.js, Deno, Bun i każdej nowoczesnej przeglądarce.
    Iteracja dopasowań przez String.matchAll
    Globalna iteracja używa `text.matchAll(regex)` zamiast ręcznej pętli lastIndex, więc każde dopasowanie niesie swoje grupy przechwytujące, grupy nazwane oraz (z /d) indeksy [start, end]. Dopasowania zerowej szerokości obsługiwane są standardowym zwiększeniem lastIndex o +1, aby uniknąć nieskończonych pętli.
    Timeout zegara ściennego dla ochrony przed ReDoS
    Budżet 250 milisekund opakowuje każde wywołanie match, replace i split. Silnik nadal może wewnętrznie nawracać przy pojedynczej próbie dopasowania, ale zewnętrzna iteracja współpracuje z budżetem — patologiczne wzorce przerywają się z `timedOut: true`, a UI wyświetla ostrzeżenie zamiast blokować kartę.
    Reimplementacja szablonu zamiany
    Zakładka Zamień parsuje $1..$N, $&, $`, $', $$ i $ ręcznie zamiast delegować do `String.replace`, więc podgląd zachowuje się identycznie w różnych silnikach (starsze Safari, starsze Node), gdzie szablony grup nazwanych mają przypadki graniczne. Wyjście jest dokładnie tym, co produkują obecne silniki JavaScript.
    Tokenizer wzorca dla wyjaśniacza
    Zakładka Wyjaśnij uruchamia ręcznie napisany tokenizer, który klasyfikuje każdy fragment wzorca (escape / metaznak / kwantyfikator / klasa znaków / otwarcie grupy / zamknięcie grupy / kotwica / alternatywa). Nieznane konstrukty wpadają do `literal` z ogólną notatką, więc wyjaśniacz nigdy cicho nie pomija treści.
    Permalinki przez hash URL (nigdy nie przesyłane)
    Stan udostępniania jest zakodowany we fragmencie location.hash (`#p=…&f=…&t=…&tab=…`). Przeglądarki nigdy nie przesyłają fragmentu w zapytaniach HTTP, więc serwery go-tools.org otrzymują zero danych, gdy permalink jest otwierany. Hydratacja odbywa się w całości na urządzeniu odbiorcy.

    Najlepsze praktyki regex

    Zakotwicz wzorce, gdy tego chcesz
    `^pattern$` dopasowuje dokładny string; `pattern` dopasowuje gdziekolwiek. Zły wybór to najczęstszy bug w walidacji formularzy: brakujące `^` przepuszcza wiodące `attacker.com/` przez kontrolę domeny; brakujące `$` przepuszcza końcowe śmieci. Użyj zakładki Dopasuj względem celowo zepsutych próbek, aby potwierdzić, co zostaje odrzucone.
    Preferuj grupy nieprzechwytujące dla czystej struktury
    `(?:foo|bar)+` i `(foo|bar)+` są funkcjonalnie identyczne, ale pierwsza nie alokuje grupy przechwytującej. Sięgaj po `(?:…)`, gdy grupa istnieje tylko dla kwantyfikatora lub alternatywy — stabilizuje Twoje numerowane $1..$N i oszczędza odrobinę pracy silnika.
    Używaj flagi /u dla wszystkiego poza ASCII
    Bez /u kropka i `\w` traktują znaki par zastępczych (emoji, punkty kodowe poza BMP) jako dwie jednostki UTF-16. Z /u są to po jednym punkcie kodowym każdy — to, co dostrzegą Twoi użytkownicy. /u włącza też `\p{Letter}` i inne escape'y właściwości. Domyślnie stosuj /u dla nowych wzorców, chyba że masz konkretny powód, żeby tego nie robić.
    Nazywaj swoje grupy przechwytujące
    `(?\d{4})-(?\d{2})` jest samoopisujące. Sześć miesięcy później, gdy czytasz regex z powrotem, `m.groups.year` to oczywiście rok — `m[1]` nie jest. Szablony zamiany z $ przeżywają zmianę kolejności grup; szablony pozycyjne łamią się w chwili, gdy ktoś doda kolejną grupę.
    Testuj przypadki niepowodzenia, nie tylko sukcesu
    Tester regex jest dla porażek. Potwierdź, co Twój wzorzec dopasowuje, a następnie celowo mutuj tekst testowy, aby zobaczyć, czego nie dopasowuje — wiodące białe znaki, końcowe białe znaki, brakujące części, dodatkowe części, zła wielkość liter, mieszane pisma. Wzorce, które przechodzą poprawne wejście, ale akceptują śmieci, to bugi, które produkcja odsłania jako pierwsze.

    Często zadawane pytania

    Czy mój regex lub tekst testowy jest wysyłany na wasz serwer?
    Nie. Każda operacja dopasowania, zamiany, podziału i wyjaśnienia działa w JavaScript w Twojej przeglądarce z użyciem natywnego silnika RegExp. Twój wzorzec i tekst nie są przesyłane, nie są logowane, nie są przechowywane na dysku ani wysyłane do żadnej strony trzeciej. Tylko Twoje preferencje UI (aktywna zakładka i flagi, które zwykle masz włączone) są zapisywane w localStorage, aby strona pamiętała je przy następnej wizycie — nigdy wzorzec ani tekst testowy. Możesz to zweryfikować, otwierając DevTools → Network: pisanie w którymkolwiek polu wywołuje zero zapytań. To czyni narzędzie bezpiecznym dla wzorców firmowych, zanonimizowanych próbek logów, wewnętrznej konfiguracji i wszystkiego innego, czego nie wkleiłbyś do regex101.
    Jakiej odmiany regex używa ten tester — PCRE, Python, Java, JavaScript?
    ECMA-262 (JavaScript), dialekt zaimplementowany przez V8, JavaScriptCore i SpiderMonkey — ten sam silnik, który otrzymujesz z `new RegExp(pattern, flags)` w dowolnej przeglądarce, Node.js, Deno czy Bun. Oznacza to, że obsługiwane funkcje to: grupy przechwytujące (numerowane + nazwane z `(?...)`), lookahead `(?=...)` i `(?!...)`, lookbehind `(?<=...)` i `(?...)`, kwantyfikatory zaborcze `a++`, warunki `(?(1)yes|no)` i modyfikatory inline `(?i)`, rzucą błąd składni. Pythonowe `re.VERBOSE` nie jest tutaj obsługiwane. Dla regex Python/Java/Go przenieś wzorzec z powrotem do natywnego silnika — większość prostych wzorców przenosi się bez zmian, a wyjaśniacz tutaj jest neutralny względem odmiany.
    Co robi każda z flag g, i, m, s, u, y, d?
    g (global) — znajdź każde dopasowanie, nie tylko pierwsze; wymagane do iteracji z .matchAll i do zamiany globalnej. i (case-insensitive) — A i a dopasowują się do tego samego znaku. m (multiline) — ^ i $ zakotwiczają się przy każdym podziale linii, a nie tylko na początku/końcu całego wejścia. s (dotAll) — . dopasowuje również nowe linie; bez /s kropka zatrzymuje się na \n. u (unicode) — włącza escape'y \u{HHHH}, escape'y właściwości Unicode (\p{Letter}) i traktuje wzorzec jako sekwencję punktów kodowych Unicode zamiast jednostek kodu UTF-16. y (sticky) — kotwiczy każde dopasowanie przy lastIndex, przydatne dla tokenizerów. d (hasIndices, ES2022) — wypełnia `.indices` i `.indices.groups` parami [start, end] dla każdego przechwytu; ten tester używa /d pod maską, aby narysować granice grup. Przełączaj je jako chipy nad tekstem testowym; kanoniczny literał /pattern/flags pokazywany jest w odczycie.
    Jak pisać grupy przechwytujące i jak się do nich odwoływać?
    Otocz podwzorzec nawiasami: `(\d{4})-(\d{2})-(\d{2})` daje trzy grupy pozycyjne, dostępne jako $1, $2, $3 w zamianach lub jako m.groups[0..2] w panelu Dopasowania. Użyj `(?...)` dla grup nazwanych: `(?\d{4})-(?\d{2})` pozwala napisać $/$ w szablonie zamiany. Użyj `(?:...)` dla grupy nieprzechwytującej, gdy potrzebujesz grupowania tylko dla kwantyfikatora (`(?:foo|bar)+`) — nie tworzy ona odwołania wstecznego, co stabilizuje Twoje numerowane $1..$N. W tym samym wzorcu odwołuj się do wcześniejszego przechwytu przez `\1`, `\2` itd. — przydatne do znajdowania zdublowanych słów, jak `\b(\w+)\s+\1\b`.
    Jak działają lookahead i lookbehind i do czego się przydają?
    Lookaroundy to asercje zerowej szerokości — sprawdzają, czy coś się dopasowuje (lub nie), bez konsumowania znaków. `(?=foo)` (positive lookahead) udaje się, jeśli `foo` następuje po bieżącej pozycji; `(?!foo)` (negative lookahead) udaje się, jeśli `foo` NIE następuje. `(?<=foo)` i `(?
    Dlaczego mój regex zawiesza przeglądarkę i czym są katastrofalne nawroty?
    Katastrofalne nawroty (catastrophic backtracking) zdarzają się, gdy wzorzec ma zagnieżdżone kwantyfikatory nad nakładającymi się alternatywami — klasyczny kształt to `(a+)+`, `(a|aa)+`, `(\w*)*` lub `(?:a|a?)+`. Na wejściu, gdzie dopasowanie może zawieść przy ostatnim znaku, silnik próbuje wykładniczej liczby podziałów grup, zanim się podda. Na `aaaaaaaaaaaaaaaaaaaaab` ze wzorcem `(a+)+b` to 2^21 ≈ 2 miliony nawrotów przed odpowiedzią. Ten tester opakowuje każde wywołanie dopasowania w budżet zegara ściennego 250 ms — jeśli budżet zostanie przekroczony, iteracja się zatrzymuje i widzisz ostrzeżenie Wzorzec przekroczył limit czasu. Naprawy: zakotwicz wzorzec do jego granic (`^...$`), preferuj alternatywy bez nakładania (`(a|b)` zamiast `(a|aa)`), rozwiń zagnieżdżone kwantyfikatory (`a+` zamiast `(a+)+`) lub przepisz, aby użyć idiomów w stylu zaborczym (`(?=(a+))\1` symuluje `a++` w JS).
    Czym ten tester regex różni się od regex101.com?
    Trzy różnice. (1) Prywatność: regex101 wysyła każde naciśnięcie klawisza na swoje serwery do oceny backendu i przechowuje wzorce we współdzielonych linkach społecznościowych; to narzędzie działa w całości w Twojej przeglądarce, bez zapytań sieciowych. (2) Szybkość: rundtrip serwerowy przy każdej zmianie dodaje 80-300 ms; tutaj dopasowania aktualizują się w mniej niż 10 ms nawet na długim tekście. (3) Skupienie na odmianie: regex101 obsługuje PCRE, Python, Java, .NET, JavaScript, Rust i Go z UI flag funkcji; to narzędzie skupia się na ECMA-262 (JavaScript) — odmiana, którą wysyłają każda przeglądarka, Node, Deno i Bun — a wyjaśniacz oraz permalinki są dostrojone do tej jednej odmiany. Jeśli potrzebujesz funkcji wyłącznie PCRE, regex101 nadal jest właściwym narzędziem; dla pracy w JavaScript / TypeScript to jest szybsze i bardziej prywatne. Permalinki tutaj to hashe URL (bez przesyłania), więc udostępniony link odtwarza Twój wzorzec lokalnie na komputerze odbiorcy.
    Jak escapować znaki specjalne typu . | ( ) [ ] { } * + ? ^ $ \?
    Postaw przed nimi backslash: `\.`, `\|`, `\(`, `\)`, `\[`, `\]`, `\{`, `\}`, `\*`, `\+`, `\?`, `\^`, `\$`, `\\`. Ukośnik `/` nie wymaga escape'owania we wzorcu przekazywanym jako string (tylko w literałach regex JS między ukośnikami). Wewnątrz klasy znaków `[...]` większość metaznaków traci specjalne znaczenie, więc `[.]`, `[*]`, `[+]` dopasowują dosłowny znak — jedyne metaznaki, które pozostają specjalne, to `]`, `\`, `^` (tylko na początku do negacji) i `-` (zakres, gdy między dwoma znakami). W razie wątpliwości wklej dosłowny tekst do wzorca i uruchom wyjaśniacz: każda sekwencja escape dostaje jednolinijkowy opis w panelu rozbioru.
    Czy mogę udostępnić regex koledze przez link?
    Tak — i link nie zawiera żadnego rundtripu serwerowego. Kliknij Kopiuj link na pasku akcji: tester koduje Twój wzorzec, flagi, tekst testowy i aktywną zakładkę do hasha URL (`#p=...&f=gim&t=...&tab=match`). Każdy, kto otworzy link, hydratuje stronę z tym samym stanem — lokalnie na swoim komputerze. Ponieważ dane żyją we fragmencie hash, nigdy nie są wysyłane na serwer go-tools.org (przeglądarki nie przesyłają fragmentów w zapytaniach) i nie są logowane w naszych logach dostępu. Długość linku rośnie z rozmiarem tekstu, więc dla próbek >2 KB skopiuj regex przez Kopiuj /pattern/flags, a tekst wklej osobno. Dla wspólnej recenzji regex bez udostępniania faktycznego tekstu udostępnij tylko wzorzec i flagi — odbiorca wkleja własny korpus i dostaje te same dopasowania.
    Czy tester obsługuje Unicode, emoji i pisma niełacińskie?
    Tak. Włącz flagę /u, aby zdecydować się na pełną obsługę Unicode: \w dopasowuje łacińskie znaki słowne (semantyka domyślna), ale z /u możesz dopasowywać szersze kategorie przez escape'y właściwości Unicode — `\p{Letter}` dopasowuje każdą literę w każdym piśmie, `\p{Script=Han}` dopasowuje ideogramy chińskie, `\p{Emoji}` dopasowuje emoji, `\p{Number}` dopasowuje każdą cyfrę/liczebnik. Bez /u emoji par zastępczych, takie jak 👨‍💻, są widziane jako dwie jednostki kodu UTF-16, a wzorce typu `^.$` nie zdołają ich dopasować; z /u kropka traktuje każdy punkt kodowy grafemu jako jeden znak. Dla pism RTL (arabski, hebrajski) wzorce działają bez specjalnej obsługi — kierunek jest sprawą renderowania, a nie silnika regex. Treść CJK dopasowuje się tak samo jak łacińska.
    Jaka jest różnica między .match, .matchAll, .replace i .split z regex?
    String.prototype.match zwraca pierwsze dopasowanie (lub tablicę wszystkich dopasowań, gdy ustawione jest /g), ale traci grupy przechwytujące, gdy /g jest włączone. String.prototype.matchAll wymaga /g i zwraca iterator tablic dopasowań Z grupami przechwytującymi i indeksami — to, czego ten tester używa wewnętrznie. String.prototype.replace przyjmuje albo szablon string ($1, $& itd.), albo callback wywoływany na dopasowanie z (match, ...groups, offset, string, namedGroups). String.prototype.split dzieli na każdym dopasowaniu — przydatne z /g, ale flaga global jest ignorowana w semantyce split. To narzędzie eksponuje match przez zakładkę Dopasuj, replace przez Zamień i split przez Podziel, więc możesz podglądnąć każdy wariant bez opuszczania strony; literał /pattern/flags jest oddalony o jedno kliknięcie, gdy będziesz gotowy wkleić do kodu.
    Dlaczego mój regex Python lub Java tu nie działa?
    Ponieważ ten tester uruchamia ECMA-262 (JavaScript) — większość wzorców przenosi się czysto, garść nie. Częste pułapki przenoszenia: (1) Pythonowe flagi inline `(?i)` i `(?x)` nie są poprawne w JS — użyj chipów flag powyżej zamiast tego. (2) Pythonowe `\A` i `\Z` to `^` i `$` w JS (z /m dla kotwic liniowych). (3) Warunki Java/Python `(?(name)yes|no)` nie są obsługiwane w JS — przepisz z alternatywą. (4) Kwantyfikatory zaborcze `a++` i grupy atomic `(?>...)` są niedostępne w JS — symuluj przez `(?=(a+))\1`. (5) Pythonowe `(?P...)` to `(?...)` w JS. (6) `\h` dla poziomej spacji i `\v` dla pionowej nie są w JS — użyj `[ \t]` i `[\n\r]`. Dla przenośnego portu wyjaśniacz rozkłada, co robi każdy token, więc możesz zamienić nieobsługiwaną składnię na ekwiwalent.
    Czy istnieje maksymalny rozmiar tekstu lub liczba dopasowań?
    Praktyczny limit: około 200 000 znaków tekstu testowego i 500 podświetlonych dopasowań wyświetlanych jednocześnie. Powyżej 500 dopasowań panel Dopasowania pokazuje baner Pokazuje pierwsze 500; odznaka liczby nadal raportuje prawdziwą sumę. Budżet zegara ściennego 250 ms ogranicza wzorce wymykające się spod kontroli niezależnie od rozmiaru. Dla wielomegabajtowych plików logów uruchom regex przez wiersz poleceń `grep -oE` lub `rg` (ripgrep) — strumieniują i nie napotkają limitu renderowania UI. Dla jednorazowych skanów ogromnego tekstu wklej reprezentatywny fragment do tego testera, aby zwalidować wzorzec, a następnie uruchom zwalidowany wzorzec na pełnym pliku w swojej powłoce.

    Powiązane narzędzia

    Zobacz wszystkie narzędzia →

    Porównanie tekstów i Diff

    Przetwarzanie tekstu

    Porównaj dwa teksty natychmiast w przeglądarce. Widok obok siebie, podświetlanie słów, eksport unified diff, opcje ignorowania wielkości liter/spacji/pustych wierszy. 100 % w przeglądarce — bez przesyłania.

    Darmowy licznik słów i znaków online

    Przetwarzanie tekstu

    Licz słowa, znaki, zdania, akapity i czas czytania na bieżąco. Licznik na żywo z kontrolą limitów Twittera, meta description i Instagrama. Za darmo, prywatnie, bez rejestracji.

    Konwerter systemów liczbowych — binary, hex, decimal i octal

    Narzędzia konwersji

    Konwertuj między systemami binarnym, szesnastkowym, dziesiętnym i ósemkowym (2–36) w czasie rzeczywistym. Bezpłatnie i prywatnie — w przeglądarce.

    Koder i dekoder Base64

    Kodowanie i formatowanie

    Zakoduj i zdekoduj Base64 online za darmo. Konwersja w czasie rzeczywistym z pełną obsługą UTF-8 i emoji. 100% w przeglądarce, bez rejestracji.

    Generator crontab i kreator wyrażeń cron

    Data i czas

    Buduj, waliduj i dekoduj wyrażenia cron w przeglądarce. Podgląd kolejnych uruchomień w czasie lokalnym lub UTC. Składnia POSIX 5-polowa, presety, opis po polsku. Za darmo, prywatnie, bez rejestracji.

    Konwerter CSV na JSON

    Kodowanie i formatowanie

    Konwertuj CSV na JSON w przeglądarce. RFC 4180, wnioskowanie typów, nagłówek, big-int safe. 100% prywatnie, bez wysyłki.