Tester Wyrażeń Regularnych

Testuj wyrażenia regularne na tekście i podświetl wszystkie dopasowania

Wypróbuj przykład

Wzór

//g

Łańcuch testowy

Działa lokalnie · Bezpieczne do wklejania sekretów

Czym jest wyrażenie regularne?

Wyrażenie regularne (regex lub regexp) to ciąg znaków definiujący wzorzec wyszukiwania. Testery regex pozwalają napisać wzorzec, uruchomić go na przykładowym tekście i zobaczyć wszystkie dopasowania podświetlone w czasie rzeczywistym. Koncepcja sięga pracy matematyka Stephena Kleene'ego nad językami regularnymi w latach 50. XX wieku, a Ken Thompson wbudował pierwszy silnik regex do edytora tekstu QED w 1968 roku.

Silnik regex czyta wzorzec od lewej do prawej, konsumując kolejne znaki wejściowe podczas dopasowywania. Stosuje nawracanie (backtracking), gdy częściowe dopasowanie zawodzi: silnik cofa się i próbuje alternatywnych ścieżek przez wzorzec. Niektóre silniki (jak RE2 używany w Go) całkowicie unikają nawracania, konwertując wzorce na deterministyczne automaty skończone (DFA), co gwarantuje liniowy czas dopasowania kosztem braku obsługi funkcji takich jak odwołania wsteczne.

Składnia regex jest luźno ustandaryzowana. PCRE (Perl Compatible Regular Expressions) to najczęściej stosowana odmiana, obsługiwana przez PHP, moduł re w Pythonie i JavaScript z drobnymi różnicami. POSIX definiuje bardziej ograniczoną składnię używaną przez grep i sed. Różnice mają znaczenie przy przenoszeniu wzorców między językami: asercja lookahead działająca w JavaScript może w ogóle nie skompilować się w silniku RE2 używanym przez Go.

Dlaczego warto używać testera regex online?

Pisanie regex w pliku kodu oznacza zapisywanie, uruchamianie i sprawdzanie wyniku za każdym razem, gdy zmieniasz wzorzec. Tester regex w przeglądarce skraca tę pętlę zwrotną do zera: piszesz i od razu widzisz dopasowania.

Podświetlanie dopasowań w czasie rzeczywistym
Każde naciśnięcie klawisza natychmiast aktualizuje wyniki dopasowania. Widzisz, które części tekstu pasują, które grupy przechwytujące są wypełnione i dokładnie gdzie każde dopasowanie się zaczyna i kończy. Bez cyklu kompilacja–uruchomienie–debugowanie.
🔒
Przetwarzanie bez wysyłania danych
Dopasowywanie wzorców odbywa się w przeglądarce przy użyciu silnika JavaScript RegExp. Żaden tekst ani wzorzec nie jest wysyłany na serwer. Ma to znaczenie podczas testowania na plikach dzienników, danych klientów lub odpowiedziach API zawierających wrażliwe informacje.
🔍
Wizualna inspekcja dopasowań
Dopasowania są podświetlane w tekście wraz z ich pozycjami i wartościami grup przechwytujących. Wizualne oglądanie dopasowań ułatwia wychwycenie błędów o jeden w kwantyfikatorach lub brakujących kotwicach.
🌐
Bez logowania i instalacji
Działa na każdym urządzeniu z nowoczesną przeglądarką. Bez konta, rozszerzenia ani wtyczki do IDE. Otwórz stronę, wklej wzorzec i tekst, a następnie zacznij testować.

Zastosowania testera regex

Walidacja danych wejściowych we frontendzie
Buduj i weryfikuj wzorce dla pól adresu e-mail, numeru telefonu lub karty kredytowej, zanim osadzisz je w atrybutach pattern HTML5 lub logice walidacji JavaScript.
Parsowanie logów po stronie backendu
Pisz wzorce regex wyodrębniające znaczniki czasu, kody błędów lub adresy IP z logów aplikacji. Testuj na rzeczywistych próbkach logów, aby potwierdzić, że wzorzec przechwytuje właściwe grupy.
DevOps i infrastruktura
Debuguj regex używane w blokach location Nginx, regułach przepisywania Apache lub regułach alertowania Prometheus. Błędny wzorzec w konfiguracji serwera może zepsuć routing lub całkowicie pominąć alerty.
QA i automatyzacja testów
Sprawdzaj, czy treść odpowiedzi lub wynik HTML pasuje do oczekiwanych wzorców w asercjach testów end-to-end. Przetestuj regex tutaj przed dodaniem go do zestawu testów.
Potoki ekstrakcji danych
Prototypuj wzorce do wyodrębniania ustrukturyzowanych pól z nieustrukturyzowanego tekstu: scrapowanie cen produktów, parsowanie przypadków brzegowych CSV lub wyciąganie metadanych z nagłówków e-mail.
Nauka wyrażeń regularnych
Eksperymentuj z metaznakami, kwantyfikatorami i grupami na przykładowych łańcuchach. Natychmiastowa wizualna informacja zwrotna sprawia, że nauka składni regex jest łatwiejsza niż sama lektura dokumentacji.

Skrócony przewodnik po składni regex

Poniższa tabela obejmuje najczęściej używane tokeny regex. Działają one w JavaScript, Pythonie, Go, PHP i większości silników zgodnych z PCRE. Rozszerzenia specyficzne dla danego języka (takie jak warunkowe wzorce Pythona lub nazwane grupy JavaScript ze składnią \k) są opisane w sekcji z przykładami kodu.

WzorzecNazwaOpis
.Any characterMatches any single character except newline (unless s flag is set)
\dDigitMatches [0-9]
\wWord characterMatches [a-zA-Z0-9_]
\sWhitespaceMatches space, tab, newline, carriage return, form feed
\bWord boundaryMatches the position between a word character and a non-word character
^Start of string/lineMatches the start of the input; with m flag, matches start of each line
$End of string/lineMatches the end of the input; with m flag, matches end of each line
*Zero or moreMatches the preceding token 0 or more times (greedy)
+One or moreMatches the preceding token 1 or more times (greedy)
?OptionalMatches the preceding token 0 or 1 time
{n,m}Quantifier rangeMatches the preceding token between n and m times
()Capturing groupGroups tokens and captures the matched text for back-references
(?:)Non-capturing groupGroups tokens without capturing the matched text
(?=)Positive lookaheadMatches a position followed by the given pattern, without consuming it
(?<=)Positive lookbehindMatches a position preceded by the given pattern, without consuming it
[abc]Character classMatches any one of the characters inside the brackets
[^abc]Negated classMatches any character not inside the brackets
|AlternationMatches the expression before or after the pipe

Flagi regex — wyjaśnienie

Flagi (zwane też modyfikatorami) zmieniają sposób, w jaki silnik przetwarza wzorzec. W JavaScript dodajesz je po zamykającym ukośniku: /pattern/gi. W Pythonie przekazujesz je jako drugi argument: re.findall(pattern, text, re.IGNORECASE | re.MULTILINE). Nie wszystkie flagi są dostępne w każdym języku.

FlagaNazwaZachowanie
gGlobalFind all matches, not just the first one
iCase-insensitiveLetters match both uppercase and lowercase
mMultiline^ and $ match start/end of each line, not just the whole string
sDot-all. matches newline characters as well
uUnicodeTreat the pattern and subject as a Unicode string; enables \u{FFFF} syntax
yStickyMatches only from the lastIndex position in the target string

Przykłady kodu

Działające przykłady regex w JavaScript, Pythonie, Go i wierszu poleceń. Każdy przykład pokazuje konstruowanie wzorca, wyodrębnianie dopasowań i wynik.

JavaScript
// Match all email addresses in a string
const text = 'Contact us at support@example.com or sales@example.com'
const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g

const matches = text.matchAll(emailRegex)
for (const match of matches) {
  console.log(match[0], 'at index', match.index)
}
// → "support@example.com" at index 14
// → "sales@example.com" at index 37

// Named capture groups (ES2018+)
const dateRegex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
const result = '2026-03-30'.match(dateRegex)
console.log(result.groups)
// → { year: "2026", month: "03", day: "30" }

// Replace with a callback
'hello world'.replace(/\b\w/g, c => c.toUpperCase())
// → "Hello World"
Python
import re

# Find all IPv4 addresses
text = 'Server 192.168.1.1 responded, fallback to 10.0.0.255'
pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'

matches = re.findall(pattern, text)
print(matches)  # → ['192.168.1.1', '10.0.0.255']

# Named groups and match objects
date_pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
m = re.search(date_pattern, 'Released on 2026-03-30')
if m:
    print(m.group('year'))   # → '2026'
    print(m.group('month'))  # → '03'

# Compile for repeated use (faster in loops)
compiled = re.compile(r'\b[A-Z][a-z]+\b')
words = compiled.findall('Hello World Foo bar')
print(words)  # → ['Hello', 'World', 'Foo']
Go
package main

import (
	"fmt"
	"regexp"
)

func main() {
	// Find all matches
	re := regexp.MustCompile(`\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b`)
	text := "Contact support@example.com or sales@example.com"
	matches := re.FindAllString(text, -1)
	fmt.Println(matches)
	// → [support@example.com sales@example.com]

	// Named capture groups
	dateRe := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})`)
	match := dateRe.FindStringSubmatch("2026-03-30")
	for i, name := range dateRe.SubexpNames() {
		if name != "" {
			fmt.Printf("%s: %s\n", name, match[i])
		}
	}
	// → year: 2026
	// → month: 03
	// → day: 30

	// Replace with a function
	result := re.ReplaceAllStringFunc(text, func(s string) string {
		return "[REDACTED]"
	})
	fmt.Println(result)
	// → Contact [REDACTED] or [REDACTED]
}
CLI (grep / sed)
# Find lines matching an IP address pattern
grep -E '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' access.log

# Extract email addresses from a file
grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' contacts.txt

# Replace dates from YYYY-MM-DD to DD/MM/YYYY using sed
echo "2026-03-30" | sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3\/\2\/\1/'
# → 30/03/2026

# Count matches per file in a directory
grep -rcE 'TODO|FIXME|HACK' src/
# → src/main.js:3
# → src/utils.js:1

Najczęściej zadawane pytania

Jaka jest różnica między regex a wzorcami glob?
Wzorce glob (takie jak *.txt lub src/**/*.js) to uproszczona składnia wieloznacznikowa używana do dopasowywania ścieżek plików w powłokach i narzędziach budowania. Obsługują * (dowolne znaki), ? (jeden znak) i [] (klasy znaków), ale nie mają kwantyfikatorów, grup, asercji lookahead ani alternatywy. Regex jest znacznie bardziej ekspresywny i działa na dowolnym tekście, nie tylko na ścieżkach plików. Wzorzec glob *.json jest z grubsza równoważny wyrażeniu regex ^.*\.json$.
Jak dopasować literalną kropkę lub nawias w regex?
Poprzedź znak ukośnikiem odwrotnym: \. dopasowuje literalną kropkę, \[ dopasowuje literalny nawias. Wewnątrz klasy znaków [] kropka jest już literalna i nie wymaga ucieczki. Częsty błąd to pisanie 192.168.1.1 bez ucieczki kropek, co dopasowuje 192x168y1z1, ponieważ . oznacza „dowolny znak”.
Czy moje dane testowe są wysyłane na serwer?
Nie. To narzędzie wykonuje dopasowywanie regex wyłącznie w przeglądarce przy użyciu silnika JavaScript RegExp. Żadne żądania sieciowe nie są wykonywane z twoim tekstem ani wzorcem. Możesz to potwierdzić, otwierając zakładkę Sieć w DevTools przeglądarki podczas korzystania z narzędzia.
Dlaczego mój regex działa w JavaScript, ale zawodzi w Pythonie?
JavaScript i Python używają różnych silników regex z nieco innymi zestawami funkcji. JavaScript obsługuje \d, asercje lookahead (?=) i lookbehind (?<=) od ES2018, ale nie obsługuje wzorców warunkowych, grup atomowych ani kwantyfikatorów posesywnych. Moduł re w Pythonie nie obsługuje klas właściwości Unicode \p{} (zamiast tego użyj zewnętrznego modułu regex). Zawsze testuj w silniku docelowego języka lub sprawdź dokumentację regex danego języka.
Co powoduje katastrofalne nawracanie w regex?
Katastrofalne nawracanie (catastrophic backtracking) następuje, gdy wzorzec ma zagnieżdżone kwantyfikatory tworzące wykładniczą liczbę ścieżek dopasowania. Klasycznym przykładem jest (a+)+ zastosowane do łańcucha samych liter a, za którymi następuje niedopasowujący się znak. Silnik próbuje każdego możliwego sposobu podziału liter a między grupę wewnętrzną i zewnętrzną przed porażką. Napraw to, używając grup atomowych (?>), kwantyfikatorów posesywnych a++ lub przepisując wzorzec tak, aby unikać niejednoznacznych powtórzeń.
Czy mogę używać regex do parsowania HTML?
Regex może wyodrębniać proste wartości z fragmentów HTML, na przykład pobierać href z pojedynczego tagu <a>. Do pełnego parsowania HTML użyj właściwego parsera (DOMParser w JavaScript, BeautifulSoup w Pythonie lub html/template w Go). HTML to gramatyka bezkontekstowa, a regex obsługuje gramatyki regularne. Zagnieżdżone tagi, opcjonalne atrybuty i elementy samo-zamykające tworzą wzorce, których regex nie może dopasować w sposób niezawodny.
Jaka jest różnica między kwantyfikatorami zachłannymi a leniwymi?
Kwantyfikator zachłanny (* lub +) dopasowuje jak najwięcej znaków, a następnie cofa się, jeśli reszta wzorca zawodzi. Kwantyfikator leniwy (*? lub +?) dopasowuje jak najmniej znaków, rozszerzając się tylko gdy jest to konieczne. Dla danych wejściowych <b>jeden</b><b>dwa</b> zachłanny wzorzec <b>.*</b> dopasowuje cały łańcuch od pierwszego <b> do ostatniego </b>, podczas gdy leniwy wzorzec <b>.*?</b> dopasowuje <b>jeden</b> i <b>dwa</b> osobno.