Regex Tester

Testujte regulární výrazy oproti řetězci a zobrazte všechny zvýrazněné shody

Zkusit příklad

Vzor

//g

Testovací řetězec

Běží lokálně · Bezpečné pro vkládání tajných údajů

Co je regulární výraz?

Regulární výraz (regex nebo regexp) je posloupnost znaků definující vzor vyhledávání. Nástroje pro testování regex vám umožňují napsat vzor, spustit ho proti ukázkovému textu a zobrazit všechny shody zvýrazněné v reálném čase. Koncept sahá k práci matematika Stephena Kleeneho o regulárních jazycích v 50. letech; Ken Thompson zabudoval první regex engine do textového editoru QED v roce 1968.

Regex engine čte vzor zleva doprava a spotřebovává vstupní znaky při pokusu o shodu. Při selhání částečné shody používá zpětné navracení (backtracking): engine se vrátí a zkusí alternativní cesty vzorem. Některé enginy (například RE2 používaný v Go) zpětnému navracení zcela zabraňují převodem vzorů na deterministické konečné automaty (DFA), což zaručuje lineární časovou složitost za cenu nepodpory funkcí jako zpětné reference.

Syntaxe regulárních výrazů je standardizována volně. PCRE (Perl Compatible Regular Expressions) je nejrozšířenější varianta, podporovaná v PHP, modulu re jazyka Python a JavaScriptu s drobnými rozdíly. POSIX definuje omezenější syntaxi používanou nástrojem grep a sed. Rozdíly jsou důležité při přenášení vzorů mezi jazyky: dopředný pohled (lookahead) funkční v JavaScriptu nemusí vůbec zkompilovat v enginu RE2 jazyka Go.

Proč používat online Regex Tester?

Psaní regulárních výrazů v souboru s kódem znamená pokaždé uložit, spustit a zkontrolovat výstup. Prohlížečový regex tester zkracuje tuto zpětnou smyčku na nulu: píšete a hned vidíte shody.

Zvýrazňování shod v reálném čase
Každý stisk klávesy okamžitě aktualizuje výsledky shod. Vidíte, které části textu se shodují, které skupiny zachycení jsou naplněny a přesně kde každá shoda začíná a končí. Žádný cyklus kompilace a ladění.
🔒
Zpracování s důrazem na soukromí
Hledání vzorů probíhá ve vašem prohlížeči pomocí JavaScriptového enginu RegExp. Žádný text ani vzory nejsou odesílány na server. To je důležité při testování souborů logů, zákaznických dat nebo API odpovědí obsahujících citlivé informace.
🔍
Vizuální kontrola shod
Shody jsou zvýrazněny přímo v textu spolu se zobrazením jejich pozic a hodnot skupin zachycení. Vizuální zobrazení shod usnadňuje odhalení chyb o jeden v kvantifikátorech nebo chybějících kotvách.
🌐
Bez přihlášení ani instalace
Funguje na libovolném zařízení s moderním prohlížečem. Žádný účet, rozšíření ani plugin do IDE. Otevřete stránku, vložte vzor a text a začněte testovat.

Případy použití Regex Testeru

Validace vstupů na frontendu
Sestavte a ověřte vzory pro pole e-mailu, telefonního čísla nebo platební karty před jejich vložením do atributů pattern HTML5 nebo validační logiky v JavaScriptu.
Parsování logů na backendu
Napište regex vzory pro extrakci časových razítek, chybových kódů nebo IP adres z aplikačních logů. Testujte na reálných ukázkách logů, abyste ověřili, že vzor zachycuje správné skupiny.
DevOps a infrastruktura
Laďte regulární výrazy v blocích location Nginx, pravidlech přepisování Apache nebo pravidlech alertů Prometheus. Špatný vzor v konfiguraci serveru může narušit směrování nebo způsobit, že alerting přehlédne incidenty.
QA a testovací automatizace
Ověřte, že těla odpovědí nebo výstup HTML odpovídají očekávaným vzorům v asercích end-to-end testů. Otestujte regex zde ještě před jeho vložením do testovací sady.
Datové extrakční pipeline
Prototypujte vzory pro extrakci strukturovaných polí z nestrukturovaného textu: scrapování cen produktů, zpracování okrajových případů CSV nebo extrakce metadat z hlaviček e-mailů.
Výuka regulárních výrazů
Experimentujte s metaznaky, kvantifikátory a skupinami na ukázkových řetězcích. Okamžitá vizuální zpětná vazba usnadňuje pochopení syntaxe regulárních výrazů lépe než samotné čtení dokumentace.

Stručná referenční příručka syntaxe regex

Následující tabulka pokrývá nejpoužívanější regex tokeny. Fungují v JavaScriptu, Pythonu, Go, PHP a většině PCRE-kompatibilních enginů. Jazykově specifická rozšíření (jako podmíněné vzory Pythonu nebo pojmenované skupiny JavaScriptu se syntaxí \k) jsou uvedena v sekci s příklady kódu.

VzorNázevPopis
.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

Vysvětlení příznaků regulárních výrazů

Příznaky (také nazývané modifikátory) mění způsob, jakým engine zpracovává vzor. V JavaScriptu je přidáváte za uzavírající lomítko: /vzor/gi. V Pythonu je předáváte jako druhý argument: re.findall(vzor, text, re.IGNORECASE | re.MULTILINE). Ne všechny příznaky jsou dostupné v každém jazyce.

PříznakNázevChování
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

Příklady kódu

Funkční příklady regulárních výrazů v JavaScriptu, Pythonu, Go a na příkazovém řádku. Každý příklad ukazuje sestavení vzoru, extrakci shod a výstup.

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

Časté dotazy

Jaký je rozdíl mezi regulárními výrazy a glob vzory?
Glob vzory (jako *.txt nebo src/**/*.js) jsou zjednodušená syntaxe zástupných znaků používaná pro vyhledávání cest k souborům v shellech a nástrojích pro sestavení. Podporují * (libovolné znaky), ? (jeden znak) a [] (třídy znaků), ale postrádají kvantifikátory, skupiny, dopředné pohledy a alternaci. Regulární výrazy jsou daleko výraznější a pracují s libovolným textem, nejen s cestami k souborům. Glob vzor *.json je zhruba ekvivalentní regulárnímu výrazu ^.*\.json$.
Jak v regulárním výrazu zachytím doslova tečku nebo závorku?
Předřaďte znaku zpětné lomítko: \. odpovídá doslova tečce, \[ odpovídá doslova závorce. Uvnitř třídy znaků [] je tečka už doslova a escapování není potřeba. Běžnou chybou je psaní 192.168.1.1 bez escapování teček, což by odpovídalo i 192x168y1z1, protože . znamená "libovolný znak".
Jsou moje testovací data odesílána na server?
Ne. Tento nástroj provádí porovnávání regex výhradně ve vašem prohlížeči pomocí JavaScriptového enginu RegExp. Žádné síťové požadavky s vaším textem ani vzorem nejsou odesílány. Ověřit to můžete otevřením záložky Network v DevTools prohlížeče během používání nástroje.
Proč můj regulární výraz funguje v JavaScriptu, ale selhává v Pythonu?
JavaScript a Python používají různé regex enginy s mírně odlišnými sadami funkcí. JavaScript podporuje \d, dopředné pohledy (?=) a zpětné pohledy (?<=) od ES2018, ale nepodporuje podmíněné vzory, atomické skupiny ani posesivní kvantifikátory. Modul re jazyka Python nepodporuje třídy vlastností Unicode \p{} (použijte místo toho modul regex třetí strany). Vždy testujte v enginu cílového jazyka nebo nahlédněte do jeho dokumentace k regulárním výrazům.
Co způsobuje katastrofické zpětné navracení v regulárních výrazech?
Katastrofické zpětné navracení nastává, když vzor obsahuje vnořené kvantifikátory vytvářející exponenciální počet cest shody. Klasickým příkladem je (a+)+ aplikovaný na řetězec písmen 'a' následovaný neshodujícím se znakem. Engine zkouší všechny možné způsoby rozdělení písmen 'a' mezi vnitřní a vnější skupinu, než selže. Opravit to lze použitím atomických skupin (?>), posesivních kvantifikátorů a++, nebo přepsáním vzoru tak, aby se vyhnul nejednoznačnému opakování.
Mohu použít regulární výrazy k parsování HTML?
Regulární výrazy dokážou extrahovat jednoduché hodnoty z fragmentů HTML, například atribut href z jediného tagu <a>. Pro úplné parsování HTML použijte správný parser (DOMParser v JavaScriptu, BeautifulSoup v Pythonu nebo html/template v Go). HTML je bezkontextová gramatika a regulární výrazy zvládají pouze regulární gramatiky. Vnořené tagy, volitelné atributy a samouzavírací elementy vytvářejí vzory, které regulární výrazy nedokážou spolehlivě pokrýt.
Jaký je rozdíl mezi hladovými a líným kvantifikátory?
Hladový kvantifikátor (* nebo +) se shoduje s co nejvíce znaky a v případě selhání zbytku vzoru se vrátí zpět. Líný kvantifikátor (*? nebo +?) se shoduje s co nejméně znaky a rozšiřuje se pouze podle potřeby. Pro vstup <b>one</b><b>two</b> se hladový vzor <b>.*</b> shoduje s celým řetězcem od prvního <b> po poslední </b>, zatímco líný vzor <b>.*?</b> se shoduje s <b>one</b> a <b>two</b> samostatně.