Generator Wzorców Regex

Buduj wyrażenia regularne wizualnie z bloków tokenów i sprawdzonych szablonów RFC.

Bez przesyłania plikówBez rejestracjiNatychmiastowe wyniki
13 sprawdzonych wzorców RFC i devWizualny kreator reguł i kwantyfikatorówFragmenty kodu JS · Python · Go · Rust
Generuj Regex
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 Generator Wzorców Regex od Utiliome?

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

Modułowe Wizualne Bloki Tokenów

Konstruuj czytelne wyrażenia regularne krok po kroku, łącząc kotwice, klasy znaków, ograniczone kwantyfikatory, grupy nieprzechwytujące ((?:...)) oraz nazwane grupy przechwytujące ((?<name>...)).

Szablony Deweloperskie Zgodne z RFC

Wczytuj zweryfikowane presety dla praktycznych adresów e-mail RFC 5322, ograniczonych adresów IPv4/IPv6, znaczników czasu ISO-8601 / RFC 3339, tagów SemVer 2.0.0, identyfikatorów UUID RFC 9562, adresów URL, slugów URL oraz kolorów szesnastkowych CSS.

Snippety Kodu dla Wielu Języków

Eksportuj gotowy do kompilacji kod dla języków JavaScript (RegExp), Python (surowe ciągi re.compile), Go (surowe literały regexp.MustCompile) oraz Rust (regex::Regex), automatycznie dostosowując składnię nazwanych grup.

Natychmiastowa Walidacja Przypadków i Prywatność

Weryfikuj na żywo pozytywne i negatywne ciągi testowe podczas modyfikowania bloków. Każda zmiana szablonu, przebieg walidacji i eksport kodu działają w 100% po stronie klienta bez żadnych zapytań sieciowych.

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
Modułowe Wizualne Bloki Tokenów Konstruuj czytelne wyrażenia regularne krok po kroku, łącząc kotwice, klasy znaków, ograniczone kwantyfikatory, grupy nieprzechwytujące ((?:...)) oraz nazwane grupy przechwytujące ((?<name>...)). Ograniczone opcje bez zaawansowanej konfiguracji
Szablony Deweloperskie Zgodne z RFC Wczytuj zweryfikowane presety dla praktycznych adresów e-mail RFC 5322, ograniczonych adresów IPv4/IPv6, znaczników czasu ISO-8601 / RFC 3339, tagów SemVer 2.0.0, identyfikatorów UUID RFC 9562, adresów URL, slugów URL oraz kolorów szesnastkowych CSS. 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

Generator Wzorców Regex – instrukcja w 3 prostych krokach

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

1

Wybierz Zweryfikowany Szablon lub Dodaj Bloki Tokenów

Wybierz przetestowany preset RFC (e-mail, IPv4/IPv6, data ISO-8601, SemVer, UUID, URL, slug lub kolor hex) albo wizualnie dołączaj kotwice, zestawy znaków, literały i kwantyfikatory.

2

Skonfiguruj Kotwice, Grupy i Ciągi Testowe

Przełączaj między ścisłą walidacją całego ciągu (^...$) a dopasowywaniem podciągów, przypisuj opakowania nazwane ((?<name>...)) lub nieprzechwytujące ((?:...)) oraz sprawdzaj pozytywne i negatywne dane testowe.

3

Skopiuj Surowy Regex lub Kod dla Wybranego Języka

Wyeksportuj sam wzorzec albo skopiuj idiomatyczne snippety dla JavaScript, Python, Go lub Rust z zastosowanym escapowaniem surowych ciągów (raw strings) i składnią grup właściwą dla danego silnika.

Komponowanie Produkcyjnego Wzorca od Wizualnych Bloków Tokenów po Kod Wielojęzyczny

Szybka odpowiedź: Łącz sekwencyjnie zakotwiczone bloki tokenów, przypisuj semantyczne nazwy pól za pomocą nazwanych grup przechwytujących ((?<name>...)), waliduj na pozytywnych i negatywnych przypadkach brzegowych oraz eksportuj idiomatyczne snippety typu raw-string dopasowane do JavaScript, Python, Go i Rust.

Ręczne pisanie złożonych wyrażeń regularnych z pamięci często wprowadza subtelne błędy — takie jak niezescapowane kropki (. dopasowujące dowolny znak zamiast dosłownej kropki .), brakujące kotwice początku/końca czy błędy związane z wiodącymi zerami. Korzystając z wizualnej kompozycji tokenów, załóżmy, że potrzebujesz ścisłego walidatora Semantic Versioning 2.0.0 (SemVer), który akceptuje opcjonalny prefiks v i wyodrębnia identyfikatory major, minor, patch, prerelease oraz metadane build.

Każda reguła strukturalna przekłada się bezpośrednio na czytelną sekwencję bloków tokenów:

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

Zwróć uwagę, jak 0|[1-9]\d* egzekwuje Sekcję 2 specyfikacji SemVer 2.0.0, zezwalając na 0, ale odrzucając wiodące zera takie jak 01, oraz jak nieprzechwytujące opakowania (?:...)? chronią separatory - i + bez tworzenia dodatkowych grup numerowanych. Walidacja na pozytywnych i negatywnych zestawach danych testowych oraz eksport kodu wielojęzycznego automatycznie generują deklaracje zgodne z docelowym silnikiem:

# Zsyntetyzowany wzorzec ECMAScript / Rust
^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-]+)*))?$

# Przypadki pozytywne (Dopasowanie)
1.0.0
v2.14.3-rc.1+build.5114f85

# Przypadki negatywne (Odrzucenie: wiodące zero w numerycznym rdzeniu wersji)
v01.2.0
1.02.3

# Python (surowy ciąg re.compile + składnia nazwanych grup (?P<name>...))
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 (surowy literał w grawisach RE2 regexp.MustCompile + składnia (?P<name>...))
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-]+)*))?$`)

Ponieważ generator unika referencji wstecznych (backreferences) i asercji rozglądania (lookarounds) w standardowych szablonach, wyeksportowane wyrażenie kompiluje się bez modyfikacji zarówno w środowiskach wykonawczych RE2 o czasie liniowym (Go i Rust), jak i w silnikach z nawrotami (JavaScript i Python).

Przenośność Silników Regex Między Językami, Niuanse Walidacji RFC i Zasady Escapowania

Szybka odpowiedź: Środowiska uruchomieniowe wyrażeń regularnych dzielą się na automaty NFA z nawrotami (JavaScript RegExp, Python re) oraz silniki Thompson NFA / DFA działające w czasie liniowym (Go regexp, Rust regex). Przenośne wzorce unikają mechanizmów lookaround i referencji wstecznych, korzystają z natywnych literałów surowych ciągów (raw strings) oraz wymuszają dokładne granice oktetów i półbajtów (nibbles) zgodne z RFC.

Automaty NFA z Nawrotami a Automaty o Czasie Liniowym (Go RE2 i Rust `regex`)

Produkcyjne silniki wyrażeń regularnych dzielą się na dwa odmienne modele wykonania:

  1. NFA z nawrotami / Backtracking NFA (JavaScript RegExp, Python re): Rekurencyjnie przeszukuje gałęzie alternatyw, umożliwiając referencje wsteczne (\1, \k<name>) oraz dowolne asercje wyprzedzające i wsteczne ((?=...), (?!...), (?<=...), (?<!...)), kosztem potencjalnie wykładniczego czasu wykonania w najgorszym przypadku dla niejednoznacznych wzorców.
  2. Thompson NFA / Leniwy DFA (Go regexp, Rust regex): Przesuwa wszystkie aktywne stany automatu jednocześnie dla każdego bajtu/punktu kodowego wejścia, gwarantując złożoność czasową O(m * n) w najgorszym przypadku względem rozmiaru wzorca m i długości wejścia n. Aby zachować skończone granice stanów, Go regexp i Rust regex celowo wykluczają referencje wsteczne i asercje lookaround.

Składnia nazwanych grup przechwytujących również różni się w zależności od biblioteki standardowej: ECMAScript wymaga (?<name>...); Python re oraz Go regexp wymagają (?P<name>...); natomiast Rust regex (od wersji 1.9+) akceptuje zarówno (?<name>...), jak i (?P<name>...).

Escapowanie Surowych Ciągów (Raw Strings) w Języku Gospodarza

Osadzenie wzorca wewnątrz zwykłego ciągu w podwójnych cudzysłowach powoduje, że kompilator języka gospodarza jako pierwszy interpretuje sekwencje ucieczki ze znakiem zapobiegawczym (backslash), wymuszając podwajanie \d+\.\d+ do postaci "\\d+\\.\\d+" i rodząc ryzyko cichego uszkodzenia wzorca (na przykład zamiany "\b" na znak backspace ASCII 0x08 zamiast granicy słowa). Wyeksportowane snippety wykorzystują natywną formę surowego literału dla każdego języka:

  • JavaScript: Notacja literałowa /wzorzec/flagi (wymagająca escapowania jedynie ukośników jako \/) lub new RegExp(String.raw..., flags) przy konstrukcji dynamicznej.
  • Python: Surowe literały ciągów re.compile(r"...") (pamiętaj, że surowy ciąg w Pythonie nie może kończyć się nieparzystą liczbą znaków backslash).
  • Go: regexp.MustCompile z surowymi literałami w grawisach (backticks), z podstawieniem \x60, jeśli sam znak grawisu musi zostać dopasowany.
  • Rust: regex::Regex::new(r"...") lub haszowane surowe literały r#"..."#, gdy sam wzorzec zawiera znaki podwójnego cudzysłowu.

Granice Precyzji RFC w Szablonach Deweloperskich

  • IPv4 i IPv6 (RFC 4291 / RFC 5952): Naiwne wyrażenie \d{1,3}(?:\.\d{1,3}){3} akceptuje nieprawidłowe oktety aż do 999. Ścisła walidacja IPv4 ogranicza każdy oktet dziesiętny za pomocą (?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d), podczas gdy szablony IPv6 uwzględniają jednokrotną kompresję zer :: oraz końcówki mapowane z IPv4 (::ffff:192.0.2.128).
  • UUID (RFC 9562, zastępujące RFC 4122): Kanoniczny układ szesnastkowy 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}$ ogranicza półbajt (nibble) wersji (1–8, obejmując UUIDv7 i UUIDv8) oraz bity wariantu IETF (8, 9, a, b), z opcjonalnym złagodzeniem dla wartości specjalnych Nil (00000000-...) i Max (ffffffff-...).
  • Daty ISO-8601 / RFC 3339 i Praktyczne Adresy E-mail: Wyrażenia leksykalne wymuszają ograniczone miesiące (0[1-9]|1[0-2]), dni (0[1-9]|[12]\d|3[01]), godziny ([01]\d|2[0-3]) oraz przesunięcia stref czasowych (Z|[+-](?:[01]\d|2[0-3]):[0-5]\d), pozostawiając arytmetykę kalendarzową lat przestępnych (np. odrzucenie 30 lutego) i weryfikację skrzynek SMTP dalszej logice parsera.

Generator Wzorców Regex a Tester Regex: Którego Narzędzia Potrzebujesz?

Szybka odpowiedź: Użyj narzędzia Generator Wzorców Regex, gdy konstruujesz nowe wyrażenie regularne wizualnie z bloków tokenów, dostosowujesz sprawdzony preset RFC lub eksportujesz wyescapowany kod dla JavaScript, Python, Go i Rust. Użyj narzędzia Tester i Debugger Regex, gdy analizujesz pozycje dopasowań (offsety), słowniki grup przechwytujących i podstawienia w ciągach znaków na żywo.

Wybór między tymi dwoma narzędziami zależy od tego, czy tworzysz nowe wyrażenie, czy diagnozujesz już istniejące. Generator Wzorców Regex koncentruje się na ustrukturyzowanej syntezie, dostosowywaniu szablonów RFC oraz generowaniu kodu dla wielu języków. Gdy masz już gotowe wyrażenie i musisz zbadać każdy offset dopasowania w wielowierszowym ładunku danych, przełączać stanowe flagi ECMAScript lub podejrzeć podstawienia ciągów $<name>, otwórz Tester i Debugger Regex.

Możliwości Generator Wzorców Regex Tester i Debugger Regex
Główne Zadanie Inżynieryjne Wizualne budowanie nowych wzorców lub modyfikacja sprawdzonych szablonów RFC Debugowanie istniejących wzorców, offsetów dopasowań, flag i podstawień
Składanie Wzorca Modułowe bloki tokenów (kotwice, klasy, kwantyfikatory, nazwane grupy) Bezpośrednia, swobodna edycja wyrażenia regularnego
Biblioteka Zweryfikowanych Szablonów Wbudowane presety dla E-mail, IPv4/IPv6, ISO-8601, SemVer, UUID, URL, Slug, Hex Skupienie na dowolnych wzorcach użytkownika i ładunkach z logów
Eksport Kodu Wielojęzycznego Gotowe do skopiowania snippety dla JavaScript, Python, Go i Rust Wyjście w postaci literału regex dla JavaScript / ECMAScript
Inspekcja Grup i Offsetów Natychmiastowa walidacja na pozytywnych i negatywnych przypadkach testowych Zakresy [start, end) dla każdego dopasowania, grupy $1–$99 oraz słownik (?<name>...)
Podgląd Podstawień na Żywo Nieprzeznaczony do podglądu zastępowania ciągów znaków Podgląd replace / replaceAll w czasie rzeczywistym ($1, $<name>, $&, $$)

Zalecany Przepływ Pracy

Złóż swoje bazowe wyrażenie lub wczytaj preset RFC tutaj, w narzędziu Generator Wzorców Regex, aby uzyskać czystą strukturę grupowania, ograniczenia kwantyfikatorów zapewniające czas liniowy oraz prawidłowo wyescapowany kod szablonowy (boilerplate) dla Twojego języka backendowego lub frontendowego. Kiedy będziesz musiał przetestować, jak ten wzorzec współpracuje z wielowierszowymi plikami logów, stanem lastIndex, parami surogatów Unicode lub szablonami replaceAll, przekaż wzorzec do narzędzia Tester i Debugger Regex.

FAQ

Generator Wzorców Regex – FAQ i przewodnik techniczny

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

Dlaczego wygenerowana składnia regex różni się między językami JavaScript, Python, Go i Rust?

Choć podstawowe klasy znaków i kwantyfikatory są identyczne w poszczególnych językach, składnia nazwanych grup przechwytujących oraz ograniczenia automatów się różnią. JavaScript wymaga (?<name>...), podczas gdy moduł re w Pythonie oraz pakiet regexp w Go wymagają (?P<name>...) (biblioteka regex w Rust obsługuje obie formy). Ponadto Go i Rust kompilują wzorce do maszyn stanów Thompson NFA / DFA działających w czasie liniowym, które celowo pomijają referencje wsteczne (\1) oraz asercje lookaround ((?=...), (?<=...)), podczas gdy silniki z nawrotami w JavaScript i Pythonie je obsługują.

Czy powinienem walidować adresy e-mail za pomocą pełnego wyrażenia regularnego gramatyki RFC 5322?

Nie. Dosłowna gramatyka RFC 5322 zajmuje kilka kilobajtów, aby zezwolić na przestarzałe białe znaki w cudzysłowach, zagnieżdżone komentarze i domeny w formie literałów IP, które współczesne serwery pocztowe odrzucają, nie dowodząc przy tym, czy dana skrzynka faktycznie może odebrać wiadomość. Systemy produkcyjne łączą zwięzły wzorzec strukturalny (^[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])?)+$) z limitami długości bajtowej według RFC 5321 (64 oktety dla części lokalnej, 254 oktety dla całego adresu) oraz wysłaniem wiadomości potwierdzającej.

Jak literały surowych ciągów (raw strings) zapobiegają błędom podwójnego escapowania znaku backslash w różnych językach?

W standardowych ciągach ujętych w cudzysłowy kompilator języka gospodarza przetwarza sekwencje ucieczki ze znakiem backslash przed przekazaniem ciągu do kompilatora regex, co wymaga podwojenia \d+\s+ do postaci "\\d+\\s+" i zamienia "\b" na znak backspace ASCII zamiast granicy słowa. Natywne surowe literały omijają interpretację znaków backslash przez gospodarza: używaj literałów /\d+\s+/ w JavaScript, r"\d+\s+" w Pythonie, literałów w grawisach (backticks) w Go oraz r"\d+\s+" lub r#"..."# w Rust.

Jaka jest różnica między ścisłą walidacją całego ciągu a wyodrębnianiem podciągów?

Ścisła walidacja otacza całe wyrażenie kotwicami początku i końca (^...$ lub \A...\z w językach Python, Go i Rust, gdzie $ w module re Pythona może również dopasować pozycję bezpośrednio przed końcowym znakiem \n). Bez kotwic wyrażenie daty takie jak \d{4}-\d{2}-\d{2} działa jak wyszukiwanie podciągu i zwraca sukces dla błędnych danych wejściowych, np. foo-2026-11-01-bar. Pozostaw włączone ścisłe kotwiczenie podczas walidacji ładunków API i formularzy lub przetestuj niezakotwiczone zakresy ekstrakcji w narzędziu Tester i Debugger Regex.

W jaki sposób szablon UUID zgodny z RFC 9562 odróżnia prawidłowe identyfikatory UUID od dowolnych 36-znakowych ciągów szesnastkowych?

Standard RFC 9562 (zastępujący RFC 4122) koduje 4-bitowy numer wersji w starszym półbajcie (high nibble) trzeciej grupy ([1-8] dla UUIDv1 do UUIDv8) oraz wariant IETF w starszym półbajcie czwartej grupy ([89abAB], reprezentujący binarnie 10xx). Jeśli Twoja baza danych przechowuje również składający się z samych zer Nil UUID (00000000-0000-0000-0000-000000000000) lub składający się z samych jedynek Max UUID (ffffffff-ffff-ffff-ffff-ffffffffffff), włącz złagodzony wariant szesnastkowy lub dodaj jawne gałęzie alternatywy.