Tester wyrażeń regularnych

Nasz tester wyrażeń regularnych pozwala pisać i testować wzorce w czasie rzeczywistym z natychmiastowym podświetlaniem dopasowań. Zobacz wszystkie dopasowania, grupy przechwytujące i indeksy podczas pisania. Obsługuje wszystkie flagi regex JavaScript (global, case-insensitive, multiline, dotAll, unicode, sticky). Zawiera tryb zamiany do testowania wyszukiwania i zastępowania, a także kompleksową ściągę regex.

star 4.9
auto_awesome AI
New

Tester wyrażeń regularnych calculator

/ /
global | case-insensitive | multiline | dotAll | unicode
info Enter a pattern to start matching
0 matches
find_replace Replace Mode

                        

No matches yet

lightbulb Tips

  • •\d = digit, \w = word, \s = space
  • •Use 'g' flag to find all matches
  • •Escape special chars: \. \( \[ \+
  • •Use (?:...) for non-capturing groups

How to Use the Tester wyrażeń regularnych

edit

Wpisz wzorzec

Wpisz swój wzorzec regex w polu wzorca. Błędy składni są podświetlane w czasie rzeczywistym.

text_fields

Dodaj tekst testowy

Wklej lub wpisz tekst, który chcesz przetestować. Wyniki są podświetlane natychmiast.

tune

Przełącz flagi

Włącz flagi, takie jak globalna (g), bez uwzględniania wielkości liter (i) lub wieloliniowa (m), aby zmodyfikować zachowanie dopasowywania.

visibility

Wyświetl wyniki

Zobacz wszystkie dopasowania, grupy przechwytujące i pozycje dopasowań. Użyj trybu zamiany, aby przetestować wyszukiwanie i zamianę.

The Formula

Wyrażenia regularne to wzorce używane do dopasowywania kombinacji znaków w ciągach. Silnik wyrażeń regularnych skanuje tekst testowy od lewej do prawej, próbując dopasować wzorzec w każdej pozycji. Flagi modyfikują zachowanie dopasowywania — 'g' znajduje wszystkie dopasowania, 'i' ignoruje wielkość liter, 'm' sprawia, że ^ i $ dopasowują granice wierszy.

new RegExp(pattern, flags).exec(testString)

lightbulb Variables Explained

  • pattern Wzorzec wyrażenia regularnego do dopasowania
  • flags Flagi wyrażeń regularnych: g (globalna), i (bez uwzględniania wielkości liter), m (wieloliniowa), s (dotAll), u (unicode)
  • testString Tekst wejściowy do przetestowania pod kątem wzorca
  • exec() Zwraca szczegóły dopasowania, w tym przechwycone grupy i indeksy

tips_and_updates Pro Tips

1

Użyj flagi 'g', aby znaleźć wszystkie dopasowania, a nie tylko pierwsze

2

Znaki specjalne poprzedzaj odwrotnym ukośnikiem: \. \( \) \[ \] \{ \} \+ \* \?

3

Używaj (?:...) dla grup nieprzechwytujących, jeśli nie potrzebujesz wartości dopasowania

4

\d = cyfra, \w = znak słowa, \s = biały znak, \b = granica słowa

5

Używaj .+? (leniwy) zamiast .+ (zachłanny), aby dopasować jak najmniej

6

Flaga 'm' sprawia, że ^ i $ dopasowują początek/koniec każdej linii, a nie tylko całego ciągu

7

Testuj przypadki brzegowe: puste ciągi, znaki specjalne i bardzo długie dane wejściowe

Nasz darmowy tester wyrażeń regularnych pozwala tworzyć, testować i debugować wyrażenia regularne z podświetlaniem dopasowań na żywo. Zobacz dopasowania, grupy przechwytujące i wyniki zamiany natychmiast podczas pisania. Działa ze składnią wyrażeń regularnych JavaScript.

Tester wyrażeń regularnych online z podglądem na żywo

Wpisz wzorzec wyrażenia regularnego i zobacz dopasowania podświetlone w czasie rzeczywistym. Nasz tester wyrażeń regularnych obsługuje wszystkie flagi JavaScript, w tym:

  • global
  • case-insensitive
  • multiline
  • dotAll

Każde dopasowanie jest wyróżnione, a grupy przechwytujące są wyświetlane osobno w celu łatwego debugowania.

Kreator i debugger wyrażeń regularnych

Twórz złożone wzorce wyrażeń regularnych za pomocą naszego narzędzia interaktywnego. Zobacz dokładnie, co Twój wzorzec dopasowuje i dlaczego.

Grupy przechwytujące są numerowane i wyświetlane, co ułatwia tworzenie wzorców do:

  • ekstrakcji danych
  • walidacji
  • przetwarzania tekstu

Ściąga i dokumentacja wyrażeń regularnych

Szybka ściągawka z popularnej składni wyrażeń regularnych (regex):

  • klasy znaków (\d, \w, \s)
  • kwantyfikatory (+, *, ?, {n})
  • kotwice (^, $, \b)
  • grupy i alternatywa
  • lookahead i lookbehind

Wszystko, czego potrzebujesz do budowania wzorców regex tuż obok testera.

Czym jest wyrażenie regularne i jak działa?

Wyrażenie regularne (regex) to sekwencja znaków definiująca wzorzec wyszukiwania do dopasowywania tekstu. Silnik regex odczytuje wzorzec i skanuje ciąg wejściowy od lewej do prawej, próbując dopasować go w każdej pozycji, aż się powiedzie lub sprawdzi cały ciąg.

Według dokumentacji MDN Web Docs, wyrażenia regularne w JavaScript to obiekty tworzone za pomocą literału (/wzorzec/flagi) lub konstruktora RegExp. Formalna składnia i semantyka dopasowywania są zdefiniowane w specyfikacji języka ECMAScript utrzymywanej przez komitet TC39, natomiast szersza teoria wywodzi się z języków regularnych w teorii języków formalnych.

Większość współczesnych silników, w tym te w przeglądarce Chrome (V8), Node.js oraz .NET, wdraża mechanizmy dopasowywania z nawrotem (backtracking), które obsługują funkcje takie jak odwołania wsteczne i asercje z wyprzedzeniem/wstecz, wykraczające poza proste automaty skończone.

Jak używać klas znaków i kwantyfikatorów w wyrażeniach regularnych

Klasy znaków i kwantyfikatory to podstawowe elementy budulcowe każdego wzorca regex. Klasa znaków, taka jak [a-z], pasuje do dowolnego pojedynczego znaku z zestawu, podczas gdy klasy skrótowe, takie jak \d (cyfra), \w (znak słowny) i \s (biały znak), są zdefiniowane w specyfikacji ECMAScript i udokumentowane w MDN Web Docs.

Kwantyfikatory kontrolują powtarzanie:

  • * oznacza zero lub więcej
  • + oznacza jeden lub więcej
  • ? oznacza zero lub jeden
  • {n,m} dopasowuje od n do m razy

Połącz je, aby zbudować precyzyjne wzorce, na przykład \d{3}-\d{4} dla fragmentu numeru telefonu. Zanegowane klasy, takie jak [^0-9], pasują do wszystkiego oprócz wymienionych znaków, dając precyzyjną kontrolę nad tym, jaki tekst akceptuje Twój wzorzec.

Czym są kotwice, granice i asercje w wyrażeniach regularnych?

Kotwice i granice dopasowują pozycje, a nie znaki, pozwalając określić, gdzie musi wystąpić dopasowanie bez pochłaniania tekstu. Daszek ^ kotwiczy do początku ciągu (lub linii w trybie wieloliniowym), $ kotwiczy do końca, a \b oznacza granicę słowa między znakiem słownym a niesłownym, co dokumentują MDN Web Docs oraz specyfikacja ECMAScript.

Asercje (lookaround) rozszerzają tę ideę: lookahead (?=...) i negatywny lookahead (?!...) sprawdzają to, co następuje po wzorcu, podczas gdy lookbehind (?<=...) i (?

Te asercje o zerowej szerokości są niezbędne przy regułach haseł, walidacji oraz dopasowywaniu tokenów tylko w określonych kontekstach.

Jak używać nazwanych grup przechwytujących i odwołań wstecznych

Nazwane grupy przechwytujące pozwalają oznaczyć przechwycony podciąg w celu uzyskania czytelniejszych i łatwiejszych w utrzymaniu wzorców. Wprowadzone do JavaScriptu w ECMAScript 2018 i udokumentowane w MDN Web Docs, składnia (?\d{4}) przypisuje nazwę „rok” do grupy, do której można uzyskać dostęp przez match.groups.rok.

Odwołania wsteczne ponowne wykorzystują wcześniej przechwyconą wartość w dalszej części tego samego wzorca: \1 odnosi się do pierwszej numerowanej grupy, a \k odnosi się do nazwanej grupy. Na przykład (?['\"]).*?\k pasuje do ciągu w cudzysłowie, który zamyka się tym samym znakiem cudzysłowu, którym się rozpoczął.

Nazwane grupy poprawiają czytelność w porównaniu do indeksów pozycyjnych, zwłaszcza w złożonych wzorcach do analizy dat, adresów URL czy uporządkowanych logów.

Jak testować i debugować wyrażenia regularne do walidacji e-maili i adresów URL

Wyrażenia regularne są powszechnie używane do sprawdzania poprawności i wyodrębniania adresów e-mail oraz URL, choć pełna zgodność z RFC jest zwodniczo trudna. Format e-maila jest zdefiniowany w RFC 5322, a jego gramatyka adresowania jest na tyle złożona, że żaden krótki regex nie ujmuje jej idealnie; MDN Web Docs i specyfikacja WHATWG HTML zalecają pragmatyczny wzorzec dla pola wejściowego type=email zamiast ścisłego parsera RFC 5322.

Adresy URL podlegają ogólnej składni w RFC 3986. W przypadku większości aplikacji bardziej niezawodny niż wyczerpujące wyrażenie jest pobłażliwy wzorzec, który wyłapuje oczywiste błędy oraz rzeczywistą weryfikację dostarczenia lub żądania.

Użyj tego testera, aby sprawdzić swój wzorzec na prawidłowych i nieprawidłowych przykładach przed jego wdrożeniem, wyłapując fałszywe negatywy, które mogłyby odrzucić legalne dane użytkownika.

Czy wyrażenia regularne są bezpieczne? Zrozumienie ReDoS i zagrożeń bezpieczeństwa

Wyrażenia regularne są bezpieczne do dopasowywania, ale mogą stwarzać ryzyko odmowy usługi (DoS), jeśli wzorce są pisane nieostrożnie. Atak typu Regular Expression Denial of Service (ReDoS), udokumentowany przez OWASP, występuje, gdy silnik z nawrotem napotyka katastrofalny nawrót na spreparowanym wejściu, co powoduje wykładniczy czas działania i zawieszenie procesu. Klasycznym wyzwalaczem są zagnieżdżone lub nakładające się kwantyfikatory na niejednoznacznych wzorcach, takie jak (a+)+$ dla długiego ciągu liter „a” po których następuje niedopasowany znak.

OWASP zaleca:

  • unikaj zagnieżdżonych kwantyfikatorów
  • używaj grup atomowych lub kwantyfikatorów zachłannych tam, gdzie są obsługiwane
  • ustawiaj limity czasu wykonywania
  • nigdy nie buduj wzorców z niezaufanych danych użytkownika bez walidacji

Uruchamiając wyrażenie regularne dla tekstu kontrolowanego przez atakującego, wybierz dobrze przetestowane wzorce biblioteczne i przetestuj najgorsze scenariusze w tym narzędziu przed wdrożeniem.

Czym różnią się flagi wyrażeń regularnych w JavaScript, Pythonie i PCRE?

Flagi wyrażeń regularnych mają wspólne koncepcje w różnych językach, ale różnią się składnią i dostępnymi funkcjami. W JavaScript flagi są dodawane do literału (/wzorzec/gi) lub przekazywane jako drugi argument konstruktora RegExp, przy czym g, i, m, s, u i y są zdefiniowane w specyfikacji ECMAScript i wyjaśnione w MDN Web Docs.

Moduł re w Pythonie używa flag inline, takich jak re.IGNORECASE lub przedrostków (?i), i nie posiada flagi sticky (przylepnej). PCRE i silniki kompatybilne z Perlem, używane przez PHP i wiele narzędzi, obsługują podobne modyfikatory oraz rozszerzone funkcje.

Ten tester korzysta z silnika JavaScript, więc wzorce zachowują się dokładnie tak samo jak w przeglądarkach i Node.js. Podczas przenoszenia wzorca do innego języka należy ponownie zweryfikować zachowanie kwantyfikatorów, obsługę standardu Unicode oraz wsparcie dla lookbehind, ponieważ różnią się one w zależności od implementacji.

Najczęstsze błędy w wyrażeniach regularnych i jak ich unikać

Najczęstsze błędy w wyrażeniach regularnych dotyczą niezescapeowanych znaków specjalnych, zachłannych kwantyfikatorów i zapomnianych flag. Metaznaków takich jak . ( ) [ ] { } + * ? ^ $ | \ mają specjalne znaczenie i muszą być poprzedzone ukośnikiem wstecznym (backslashem), aby były dopasowywane dosłownie, zgodnie ze specyfikacją ECMAScript i MDN Web Docs; zwykła kropka . pasuje do dowolnego znaku, a nie tylko do kropki.

Zachłanne kwantyfikatory, takie jak .+, przesadzają i połykają więcej niż zamierzano, dlatego przy dopasowywaniu między ograniczenicami należy używać wersji leniwych .+?. Zapomnienie flagi g zwraca tylko pierwsze dopasowanie, a pominięcie kotwic pozwala wzorcom dopasowywać niezamierzone podciągi.

Inne pułapki to ignorowanie standardu Unicode za pomocą flagi u i zakładanie, że lookbehind działa wszędzie. Przetestuj przypadki skrajne, takie jak puste ciągi, znaki nowej linii i wrogie dane wejściowe w tym narzędziu, zanim opierzesz się na jakimkolwiek wzorcu.

Frequently Asked Questions

sell

Tags