Начало работы
Базовый синтаксис
Регулярные выражения используют спецсимволы для сопоставления с образцом. . совпадает с любым символом, [] задаёт классы символов, \d \w \s — сокращения для частых наборов. Внутри [] используйте ^ для отрицания.
# Basic matching
hello # literal match
. # any character except newline
[abc] # any of a, b, c
[^abc] # not a, b, or c
[a-z] # range a to z
\d # digit [0-9]
\D # non-digit
\w # word char [a-zA-Z0-9_]
\W # non-word char
\s # whitespace
\S # non-whitespaceМетасимволы
Метасимволы имеют особое значение. Чтобы сопоставить их буквально, поставьте перед ними обратный слэш. Внутри классов символов [] экранировать нужно только ] \ ^ и - (причём - только когда он не в начале и не в конце).
# Special metacharacters that need escaping:
. * + ? ^ $ { } [ ] \\ | ( )
# Escape with backslash to match literally
\. # literal dot
\* # literal asterisk
\+ # literal plus
\? # literal question mark
\( # literal parenthesis
\[ # literal bracket
\$ # literal dollar
\^ # literal caret
\\ # literal backslash
# Example: match "1.5" not "1x5"
1\.5 # matches "1.5" onlyТочка и подстановочные знаки
Точка . — самый частый подстановочный знак, но по умолчанию она не совпадает с переводом строки. Используйте флаг /s (ES2018+) или приёмы с классами вроде [\s\S] для совместимости между движками, когда нужно сопоставление через строки.
# Dot matches any char except newline (by default)
a.c # matches "abc", "a c", "a1c", "a@c"
a..c # four chars: a, any, any, c
# Dot matches newline only with /s flag (dotall)
/a.b/s # "a\nb" matches
# Match any character truly (with /s flag)
/[\s\S]/ # any char including newline (portable)
/[\d\D]/ # also any char
/[\w\W]/ # also any char
# Practical: any chars between tags
<div[\s\S]*?</div>Литералы регулярных выражений в коде
В JS чаще всего используется /pattern/flags. В Python применяйте сырые строки (r""), чтобы избежать двойного экранирования. В Java в строковых литералах нужны двойные обратные слэши. В PHP разделитель — /. В Go используются обратные кавычки или строки с двойными обратными слэшами.
# JavaScript - regex literal
const re = /\bword\b/gi;
# JavaScript - constructor (for dynamic patterns)
const re2 = new RegExp("\\bword\\b", "gi");
# Python - raw string with re module
import re
pattern = r"\bword\b"
re.search(pattern, "a word here")
# Java - String needs double escaping
Pattern p = Pattern.compile("\\bword\\b");
# PHP - Perl-style
if (preg_match('/\\bword\\b/i', $text)) { }
# Go - RE2 syntax
re := regexp.MustCompile(`\\bword\\b`)Тестирование и сопоставление
В JS test() возвращает boolean, match() возвращает совпадения. В Python search() ищет где угодно, match() привязан к началу, fullmatch() требует совпадения всей строки. Выбирайте функцию под свою задачу.
# JavaScript
/abc/.test("abcdef") # true
"abcdef".match(/abc/) # ["abc", index: 0]
"abcabc".match(/abc/g) # ["abc", "abc"]
"abcdef".search(/abc/) # 0 (index)
# Python
import re
re.search(r"abc", "abcdef") # Match object or None
re.match(r"abc", "abcdef") # anchored at start
re.fullmatch(r"abc", "abc") # entire string
# Test if pattern matches anywhere
bool(re.search(r"abc", "xabcx")) # TrueКлассы символов
Наборы символов [abc]
Квадратные скобки задают набор символов, совпадающий с любым из перечисленных. Внутри [] большинство метасимволов (. * + ? и т. д.) теряют особое значение и совпадают буквально. Особыми внутри остаются только ] \ ^ и -.
# Match any single char from the set
[aeiou] # any vowel
[abc123] # any of a, b, c, 1, 2, 3
[ABC] # uppercase A, B, or C (case-sensitive)
# In a set, most metacharacters are literal
[.*+] # literal . * or +
[()] # literal ( or )
# Quantifiers work on sets
[aeiou]{2} # exactly two vowels
[0-9]+ # one or more digitsОтрицательные наборы [^abc]
^ сразу после открывающей [ отрицает набор: совпадает с любым символом, которого нет в списке. ^ должен быть первым; в другом месте набора это литеральный символ ^. Полезно для шаблонов «до X».
# Caret at start negates the set
[^aeiou] # any char that is NOT a vowel
[^0-9] # any non-digit
[^\s] # any non-whitespace
[^a-zA-Z] # any non-letter
# Common: match up to a delimiter
[^,]+ # everything until next comma
[^;]+ # everything until next semicolon
[^"\\] # any char except quote or backslash
# Negation works with quantifiers
[^aeiou]+ # one or more non-vowelsДиапазоны [a-z]
Дефис между двумя символами создаёт диапазон по кодам символов. Диапазоны должны идти от меньшего к большему. Чтобы сопоставить литеральный дефис в наборе, поставьте его в начало или конец либо экранируйте. Избегайте [A-z] — он включает не-буквенные символы между Z и a.
# Hyphen defines a range inside []
[a-z] # lowercase letter
[A-Z] # uppercase letter
[0-9] # digit (same as \d)
[a-zA-Z] # any letter
[a-zA-Z0-9] # alphanumeric
[a-fA-F0-9] # hexadecimal digit
# ASCII order matters
[A-z] # WARNING: includes [ \ ] ^ _ `
# Multiple ranges in one set
[a-zA-Z0-9_] # word character (same as \w)
# Literal hyphen: place at start or end, or escape
[-a-z] # hyphen or lowercase letter
[a-z-] # lowercase letter or hyphen
[a\-z] # a, hyphen, or zПредопределённые сокращения
Сокращения \d \w \s лаконичны и читаемы. В режиме Unicode (по умолчанию в Python 3, в JS с /u) \d и \w совпадают не только с ASCII. Используйте re.ASCII в Python или явный [0-9] для работы только с ASCII.
# Most common shorthands (work outside and inside [])
\d # digit [0-9]
\w # word char [a-zA-Z0-9_]
\s # whitespace [ \t\n\r\f\v]
\D # non-digit
\W # non-word char
\S # non-whitespace
# With ASCII-only flag (Python)
\d # Unicode digits by default
\d # [0-9] with re.ASCII flag
# Inside character classes
[\d\s] # digit or whitespace
[\w.] # word char or literal dot
[a-z\d] # letter or digit
# POSIX classes (PCRE, not JS)
[[:alpha:]] # letters
[[:digit:]] # digits
[[:alnum:]] # alphanumeric
[[:space:]] # whitespaceОтрицательные сокращения
Заглавные версии \D \W \S отрицают свои строчные аналоги. Они включают переводы строк и другие символы. Если нужно «не цифра, но и не перевод строки», комбинируйте явно: [^\d\n].
# Uppercase versions are negations
\D # any non-digit [^0-9]
\W # any non-word char [^a-zA-Z0-9_]
\S # any non-whitespace [^\s]
# Useful for "match until X" patterns
\S+ # one or more non-whitespace (a word)
\D+ # one or more non-digits
\W # a single non-word char
# Combined with anchors
^\S+ # word at start of string
\S+$ # word at end of string
# Find non-word boundaries for tokenization
\W+ # split on punctuation/space
# Caveat: \D matches newlines too
[^\d\n] # non-digit AND non-newlineКомбинирование классов
Классы символов могут смешивать диапазоны, сокращения и литералы. Порядок не важен (кроме диапазонов и ^ в начале). С их помощью строят практичные шаблоны: email, имена файлов, идентификаторы.
# Mix shorthands, ranges, and literals in []
[\w\s] # word char or whitespace
[a-z\d_] # lowercase, digit, or underscore
[\w.-] # word char, dot, or hyphen (e.g., domain)
[^\w\s] # neither word char nor whitespace (punctuation)
# Common practical classes
[A-Z][a-z]+ # Capitalized word
\d{1,3}\.\d{1,3} # version-like number
[\w.+-]+@\w+ # email-ish
# Hex color
#[a-fA-F0-9]{3,6}
# Match identifier (variable name)
[a-zA-Z_$][\w$]*
# Filename with extension
[\w.-]+\.[a-zA-Z]{1,5}Квантификаторы
Звёздочка * (ноль или больше)
* совпадает с нулём или более вхождений предыдущего элемента. По умолчанию жадный — захватывает максимум. Добавьте ? после, чтобы сделать ленивым (*?). Часто комбинируется с ? для «необязательных» шаблонов вроде https?://
# * matches 0 or more occurrences
ab*c # "ac", "abc", "abbc", "abbbbc"
\d* # zero or more digits
\s* # optional whitespace
[a-z]* # zero or more lowercase letters
# Useful for optional content
https?:// # http:// or https:// (note the ?)
color:\s*#?[a-f0-9]+ # color: #abc or color: abc
# * is greedy - matches as much as possible
<a.*> # from <a to LAST > on the line
# Make it lazy with ?
<a.*?> # from <a to FIRST > (lazy)
.*? # zero or more, lazy
# * on group
(ab)* # "", "ab", "abab", "ababab"Плюс + (один или больше)
+ требует хотя бы одного совпадения (в отличие от *, который допускает ноль). Полезен для шаблонов «одно или больше»: слова (\w+), числа (\d+), серии пробелов (\s+). Ленивый вариант +? останавливается на первом совпадении.
# + matches 1 or more occurrences (at least one)
ab+c # "abc", "abbc", but NOT "ac"
\d+ # one or more digits (integer)
\w+ # one or more word chars (a word)
\s+ # one or more whitespace
# Common patterns
\w+@\w+ # simplistic email
\d+\.\d+ # decimal number
-?\d+ # optional sign + integer
[A-Z]+ # one or more uppercase
# Greedy by default - use +? for lazy
".+?" # quoted string (lazy: stops at first ")
".+" # greedy: matches to the LAST "
# + vs *: + requires at least one
a+ # "a", "aa", "aaa" (not "")
a* # "", "a", "aa", "aaa"Вопрос ? (ноль или один)
? делает предыдущий элемент необязательным (0 или 1). После другого квантификатора (*? +? ??) он делает тот квантификатор ленивым. Полезен для необязательных букв, знаков, разделителей и коротких или длинных форм вроде 'Nov'/'November'.
# ? matches 0 or 1 occurrence (optional)
colou?r # "color" or "colour"
https?:// # "http://" or "https://"
-?\d+ # integer with optional minus sign
[+-]?\d* # number with optional sign
# Make greedy quantifier lazy
.*? # lazy zero-or-more
.+? # lazy one-or-more
?? # lazy zero-or-one (rarely needed)
# Optional group
Nov(?:ember)? # "Nov" or "November"
Mr\.? # "Mr" or "Mr."
# Optional non-capturing group with separator
\d{4}[-/]?(\d{2}) # 2024-01 or 202401
# Chained optionals
a?b?c? # "", "a", "ab", "abc", "b", "bc", "c"Фигурные скобки {n,m}
Фигурные скобки задают точное количество: {n} (ровно n), {n,m} (от n до m), {n,} (n или больше), {0,m} (до m). Большинство движков считают { литералом, если он не образует корректный квантификатор. По умолчанию жадные, если не добавлен ?.
# Exact count
\d{3} # exactly 3 digits
[a-z]{5} # exactly 5 lowercase letters
.{10} # exactly 10 of any char
# Range: min, max
\d{2,4} # 2 to 4 digits
\w{3,} # 3 or more word chars
.{0,5} # 0 to 5 of any char (same as.....?)
# Open-ended
\d{3,} # 3 or more digits
\s{1,} # one or more whitespace (same as \s+)
\d{0,} # zero or more (same as \d*)
# Practical patterns
\d{4}-\d{2}-\d{2} # date YYYY-MM-DD
\d{1,3}(?:\.\d{1,3}){3} # IPv4 address
\d{3}-\d{3}-\d{4} # US phone
[A-Fa-f0-9]{6} # 6 hex digits
\d{4,16} # 4-16 digit PIN
# Greedy by default - add ? for lazy
\d{2,4}? # match minimum (2)Жадные квантификаторы
Жадные квантификаторы захватывают максимум, затем откатываются, чтобы остальная часть шаблона могла совпасть. Это может давать неожиданные совпадения в HTML и тексте. Используйте ленивые (*? +?) или более точные классы символов, чтобы избежать проблем.
# Quantifiers are greedy by default
# They match as MUCH as possible while allowing rest to match
".*" # in 'a "b" c "d" e', matches "b" c "d"
<a.*> # matches from <a to the LAST >
# Greedy backtracks to allow overall match
\d+\d # in "12345", \d+ takes "1234", last \d takes "5"
# Common greedy patterns
.* # entire line
.+ # entire line (at least 1 char)
\d+ # all consecutive digits
\w+ # all consecutive word chars
# Greedy can be a problem with HTML
<.*> # WRONG: matches <b>text</b> as one
<\w+> # better: matches just <b>
# Greedy with anchored end
^.*(end).*$ # .* takes everything, backtracks to find "end"Ленивые квантификаторы
Ленивые квантификаторы (также нежадные) совпадают с минимумом, расширяясь только при необходимости. Используйте их, чтобы найти кратчайшее совпадение — например, содержимое между кавычками или тегами. Для строк в кавычках шаблон '[^']*' часто яснее и быстрее, чем '.*?'.
# Add ? to make any quantifier lazy (match as LITTLE as possible)
*? # lazy zero-or-more
+? # lazy one-or-more
?? # lazy zero-or-one
{n,m}? # lazy range
# Lazy matches shortest possible
"<.*?>" # in 'a "b" c "d" e', matches "b" then "d"
<a.*?> # matches <a> to first >
# Compare: HTML tag matching
<.+> # greedy: <b>bold</b> matches as ONE
<.+?> # lazy: matches <b> then </b> separately
# Find quoted strings (lazy)
"([^"]*)" # alternative: chars that aren't a quote
# Lazy can be slower in some cases
# Prefer negated classes when possible:
"[^"]*" # often faster than ".*?"
# Multiple lazy on same line
(.*?)(.*?)(.*?) # all lazy, but each takes minimumЯкоря и границы
Якорь начала ^
^ совпадает с началом строки (или началом каждой строки с флагом /m). Это утверждение нулевой ширины — оно не потребляет символы. Не путайте с ^ внутри [], который отрицает класс символов. Используйте ^...$ для проверки строк целиком.
# ^ matches position at start of string (or line with /m)
^Hello # "Hello" only at the start
^\d+ # digits at the start
^https?:// # URL at start of string
# With multiline flag /m, ^ matches start of each line
^\s*$ # blank lines (with /m, matches each)
# Useful for validation (must start with)
^[A-Z] # must start with uppercase letter
^[a-zA-Z] # must start with a letter
# ^ inside [] is DIFFERENT (negation)
[^abc] # any char that is NOT a, b, or c
# Common validation: entire string is digits
^\d+$ # only digits, nothing else
# Line prefix matching (multiline)
^\s*#.* # comment lines starting with #Якорь конца $
$ совпадает с концом строки (или концом каждой строки с /m). Комбинируйте ^...$ для проверки, что вся строка соответствует шаблону. Осторожно с альтернацией: ^a|b$ означает (^a) ИЛИ (b$), используйте ^(a|b)$ или ^(?:a|b)$.
# $ matches position at end of string (or before final newline)
end$ # "end" only at the end
\.\w{2,4}$ # file extension at end
\d+$ # digits at the end
# With multiline flag /m, $ matches end of each line
\s*$ # trailing whitespace per line (with /m)
# Combine ^ and $ for full-string validation
^\d{4}$ # exactly 4 digits, nothing else
^[A-Z][a-z]+$ # Capitalized word, entire string
^yes|no$ # WARNING: this is (^yes) OR (no$)
# Fix the precedence issue:
^(?:yes|no)$ # entire string is "yes" or "no"
# Email-ish validation
^[\w.+-]+@[\w-]+\.[a-z]{2,}$
# Multiline: find empty lines
^$ # empty lines (with /m)Граница слова \b
\b — утверждение нулевой ширины, совпадающее с границей между \w (символ слова) и \W (не-символ слова) или краями строки. Идеально для поиска целых слов без совпадения по подстрокам. Подчёркивание — символ слова, поэтому 'foo_bar' для \b — одно слово.
# \b matches a position between a word char and non-word char
\bword\b # "word" but not "wording" or "sword"
\bcat # "cat" at start of word: cat, cats, but not scat
cat\b # "cat" at end of word: cat, scat, but not cats
\bcat\b # "cat" as a whole word only
# Useful for finding whole words
\bthe\b # "the" but not "theater" or "breathe"
# Find words of specific length
\b\w{4}\b # all 4-letter words
\b\w{4,}\b # all words with 4+ letters
# Boundary at start/end of identifier
\bUser\b # whole word "User"
\bid\b # whole word "id" (not "id" in "ride")
# Variable name as whole word
\bcount\b # "count" but not "discount" or "counter"
# Boundary between digit and non-digit
\b\d+\b # whole numbers onlyНе-граница слова \B
\B совпадает везде, где НЕТ границы слова. Полезно, когда нужно убедиться, что шаблон НЕ находится в начале или конце слова. Редко, но мощно для частных случаев вроде 'cat' внутри другого слова.
# \B is the opposite of \b - matches where there is NO word boundary
\Bword # "word" NOT at start of word: "sword", "password"
word\B # "word" NOT at end of word: "wording", "wordsword"
\Bword\B # "word" in middle of other word chars
# Find 'cat' inside another word only
\Bcat\B # matches in " concatenate " (middle 'cat')
# Useful for matching inside identifiers
\Ba\B # 'a' surrounded by word chars
# Position NOT at word boundary
\B-\B # hyphen between word chars (e.g., "well-known")
# Practical: hyphenated compound word
\w+\B-\B\w+ # NOT what you want for "well-known"
# \B at start of string with first char being non-word
\B. # any char that's NOT at a word boundary start
# Test password: 'a' must be inside word (rare)
\Ba\w+\B # 'a' not at word edgesАбсолютные якоря \A \Z \z
\A и \z/\Z — абсолютные якоря строки, на которые не влияет многострочный режим (Python, PCRE, Ruby, Java). \A — начало, \z — конец, \Z — конец или позиция перед последним переводом строки. В JS их нет — используйте ^ и $ (с /m для построчного режима). В Ruby ^ и $ всегда построчные.
# These anchors are NOT in JavaScript natively (use ^ and $)
# Available in Python, Java, PCRE, Ruby, etc.
\A # absolute start of string (not affected by /m)
\Z # end of string, or before final newline (Python/PCRE)
\z # absolute end of string (no newline tolerance)
# Python example
import re
re.search(r"\Ahello", "hello\nworld") # Match at start
re.search(r"world\Z", "hello\nworld\n") # Match (before final \n)
re.search(r"world\z", "hello\nworld\n") # No match (newline at end)
# Difference between ^ and \A with re.MULTILINE
text = "line1\nline2"
re.findall(r"^\w+", text, re.M) # ['line1', 'line2']
re.findall(r"\A\w+", text, re.M) # ['line1'] only
# JavaScript: only ^ and $ available
# Use ^ with /m for line starts
# Use $ with /m for line ends
# Ruby always treats ^ and $ as line anchors
# Use \A and \z for string anchors in RubyГруппы и захват
Захватывающие группы ()
Круглые скобки () создают захватывающую группу, которая запоминает совпавший текст для дальнейшего использования. Группы нумеруются слева направо начиная с 1. Используйте их, чтобы извлекать части совпадения или ссылаться на них в строках замены и обратных ссылках.
# Parentheses create a capturing group
(abc) # matches "abc" and captures it
(\d+) # matches digits and captures them
(a)(b)(c) # three separate capture groups
# Group with quantifier
(ab)+ # "ab", "abab", "ababab" (whole group repeated)
(\d{2,4})- # 2-4 digits followed by hyphen
# Capturing in replacement (JS)
"2024-01-15".replace(/(\d{4})-(\d{2})-(\d{2})/, "$3/$2/$1")
# Result: "15/01/2024"
# Capturing in Python
import re
m = re.search(r"(\w+)@(\w+)", "[email protected]")
m.group(1) # "user"
m.group(2) # "example"
m.groups() # ("user", "example")
# Backreference in same regex
(\w+)\s+\1 # repeated word: "hello hello"Нумерация групп
Группы нумеруются по позиции открывающей скобки слева направо. Внешние и вложенные группы идут перед своими внутренними. Синтаксис замены различается: JS/Java используют $1, Python — \1 (или \g<1>), PHP допускает и $1, и \1.
# Groups are numbered left-to-right by opening paren
(A)(B)(C) # group 1=A, 2=B, 3=C
((A)(B))(C) # group 1=AB, 2=A, 3=B, 4=C
# Nested groups: outer first, then inner
(\d{4})-(\d{2})-(\d{2}) # 1=year, 2=month, 3=day
((\d{1,3})\.){3}(\d{1,3}) # 1=last octet., 2=octet, 4=last octet
# Reference groups in replacement
# JavaScript: $1, $2, $3
"abc".replace(/(a)(b)(c)/, "$3$2$1") # "cba"
# Python: \1, \2 in re.sub; m.group(1)
re.sub(r"(\w+)@(\w+)", r"\2.\1", "user@host") # "host.user"
# Java: $1, $2 in replaceAll
"x".replaceAll("(x)", "$1$1") # "xx"
# PHP: $1 or \1 in preg_replace
preg_replace('/(\w+)@(\w+)/', '$2.$1', 'user@host')
# Whole match: $& (JS), \g<0> (Python), $0 (Java/PHP)Без захвата (?:...)
Используйте (?:...) для группировки, когда захват не нужен. Это экономит память, делает нумерацию захватывающих групп предсказуемой и отражает намерение. Особенно важно при альтернации или квантификаторах на подшаблонах, где захваченное значение не нужно.
# (?:...) groups WITHOUT capturing (saves memory, cleaner groups)
(?:abc)+ # "abc" repeated, but no capture
(?:\d{1,3}\.){3}\d{1,3} # IPv4, no extra captures
# Compare: capturing vs non-capturing
(\d{4})-(\d{2}) # 2 groups captured
(?:\d{4})-(?:\d{2}) # 0 groups captured (just match)
# Use non-capturing when you don't need the captured value
https?://(?:www\.)?(\w+) # capture just the domain
(?:Mr|Mrs|Ms)\.\s+\w+ # title prefix, no capture needed
# Combine with alternation
(?:cat|dog|bird)s? # plural animals, no capture
# With quantifier on alternation
(?:\d+\s*)+ # numbers separated by spaces
# Why use it?
# 1. Saves memory (no captured text stored)
# 2. Keeps group numbering clean
# 3. Documents intent: "this is just for grouping"Именованные группы (?<name>...)
Именованные группы (?<name>...) в JS/.NET или (?P<name>...) в Python/PCRE делают шаблоны самодокументируемыми. Ссылайтесь по имени в замене ($<name> в JS, \g<name> в Python) и в обратных ссылках (\k<name> в JS, (?P=name) в Python).
# Named capture group - JavaScript, .NET, Python 3.x style
(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})
# Python uses (?P<name>...) - same as PCRE
(?P<year>\d{4})-(?P<month>\d{2})
# Reference in replacement
# JavaScript:
"2024-01-15".replace(
/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/,
"$<d>/$<m>/$<y>"
) # "15/01/2024"
# Python:
re.sub(
r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})",
r"\g<d>/\g<m>/\g<y>",
"2024-01-15"
) # "15/01/2024"
# Reference by name in same regex (backreference)
(?<word>\w+)\s+\k<word> # JS
(?P<word>\w+)\s+(?P=word) # Python
# Access named groups in Python
m = re.match(r"(?P<year>\d{4})", "2024")
m.group("year") # "2024"
m.groupdict() # {"year": "2024"}Альтернация |
Альтернация | совпадает с одним из нескольких шаблонов. У неё очень низкий приоритет, поэтому используйте скобки для ограничения области. Движки перебирают варианты слева направо и выбирают первый, при котором общее совпадение удаётся, — порядок важен, когда варианты пересекаются.
# | means OR - matches one of several alternatives
cat|dog|bird # "cat" OR "dog" OR "bird"
yes|no # "yes" or "no"
\d{2}|\d{4} # 2 digits OR 4 digits
# IMPORTANT: alternation has low precedence
^abc|def$ # means (^abc) OR (def$) — NOT ^abc$ or ^def$
# Use groups to scope alternation
^(abc|def)$ # entire string is "abc" or "def"
^(?:cat|dog)s?$ # "cat", "cats", "dog", "dogs"
# Order matters - first match wins
a|ab # in "ab", matches just "a" (leftmost wins)
ab|a # in "ab", matches "ab"
# Common: file extensions
\.(?:jpg|png|gif|bmp)$
# HTML tags
</?(?:div|span|p|a)\b
# Day names
(?:Mon|Tues?|Wed|Thurs?|Fri|Sat|Sun)day
# Number formats
\d{1,3}(?:,\d{3})*|\d+ # 1,234 or 1234Обратные ссылки на группы
Обратные ссылки (\1, \2 или \k<name>) совпадают с тем же текстом, который был захвачен более ранней группой. Классика: парные HTML/XML-теги, повторяющиеся слова, согласованные разделители. Обратная ссылка должна совпасть именно с захваченным текстом.
# \1, \2, etc. refer to a previous capturing group's match
(\w+)\s+\1 # repeated word: "hello hello"
<(\w+)>.*?</\1> # HTML tag matching: <div>...</div>
(["\'])[^\1]*\1 # quoted string (quote char remembered)
# Named backreferences
# JavaScript: \k<name>
(?<q>["\'])[^\k<q>]*\k<q> # quoted string with named ref
# Python: (?P=name)
(?P<q>["\'])[^\2]*?(?P=q) # similar (numbered ref still works)
# Practical: matching opening/closing tags
<b>(.*?)</\1> # WARNING: \1 is "b", but...
# Better: capture tag name
<([a-z][a-z0-9]*)\b[^>]*>[\s\S]*?</\1>
# Find duplicated words
\b(\w+)\s+\1\b # "the the", "is is"
# Match paired delimiters
(\[)[^\]]*\1\] # WRONG: matches "[[..[" — use \1 for SAME char
# Date with same separator
(\d{4})([-/])(\d{2})\2(\d{2}) # 2024-01-15 (same separator)Незахватывающие группы
Базовые незахватывающие
(?:...) группирует, не создавая захват. Используйте, когда нужна группировка для альтернации или квантификаторов, но значение совпадения не важно. Это сохраняет предсказуемую нумерацию групп и немного ускоряет работу.
# (?:pattern) - group without capturing
(?:abc) # matches "abc", no capture
(?:foo|bar) # "foo" or "bar", no capture
# Compare
(\d{4})-(\d{2})-(\d{2}) # 3 capture groups
(?:\d{4})-(?:\d{2})-(?:\d{2}) # 0 capture groups (just match)
# When you only care about match/not-match
^(?:Yes|No|Maybe)$ # validate yes/no/maybe
https?://(?:www\.)?\w+ # URL prefix, only domain matters
# Keep capture numbers clean
(?:https?://)?(\w+) # group 1 = domain (prefix is non-capturing)
vs
(https?://)?(\w+) # group 1 = protocol, group 2 = domain
# Nested
(?:(?:foo|bar)-)?(\w+) # group 1 = word (after optional prefix)С квантификаторами
Незахватывающие группы хорошо сочетаются с квантификаторами, когда нужно повторить подшаблон, не сохраняя совпавший текст. Это важно для предсказуемой нумерации захватывающих групп при извлечении отдельных частей сложного шаблона.
# Apply quantifier to a non-capturing group
(?:abc)+ # "abc", "abcabc", "abcabcabc"
(?:\d{1,3}\.){3}\d{1,3} # IPv4: 3 groups of "ddd." then "ddd"
(?:\s*,\s*) # comma with optional surrounding whitespace
(?:\w+\s+)+\w+\.? # word sequence (sentence-ish)
# Compare: capturing group + quantifier keeps LAST match only
(\d,)+ # in "1,2,3,", group 1 captures "3," (last)
(?:\d,)+ # same match, no capture
# Optional group with separator
\d{4}(?:-\d{2}){2} # 2024-01-15 (no captures)
\d{4}(?:[-/]\d{2}){2} # 2024-01-15 or 2024/01/15
# Repeated pattern
(?:\d+\.)*\d+ # version number like 1.2.3
# Multiple non-capturing groups
^(?:Mr|Mrs|Ms|Dr)\.?\s+(?:[A-Z][a-z]+\s?)+$ # full name w/ title
# Avoid extra captures when extracting specific data
https?://(?:www\.)?([\w-]+)\.(?:com|org|net) # only capture domainВложенные группы
Смешивайте незахватывающие группы с захватывающими свободно. Захваты по-прежнему нумеруются по порядку открывающих скобок, но незахватывающие группы не занимают номер. Так номера захватов остаются компактными, когда важны лишь некоторые части.
# Mix capturing and non-capturing groups
(?:(\d{4})-(\d{2})-(\d{2})) # outer non-cap, 3 inner captures
# group 1=year, 2=month, 3=day
# With alternation inside non-capturing
(?:https?|ftp)://([^/]+) # group 1 = host
# Date with optional time
(\d{4}-\d{2}-\d{2})(?:[ T](\d{2}:\d{2}))?
# group 1 = date, group 2 = optional time
# Practical: parse URL
(?:([^:]+)://)? # group 1: optional scheme
([^/?#]+) # group 2: host
(?:/([^?#]*))? # group 3: optional path
(?:\?([^#]*))? # group 4: optional query
(?:#(.*))? # group 5: optional fragment
# CSV-ish parser (simplified)
(?:^|,)(?:"([^"]*)"|([^,]*))
# group 1: quoted field, group 2: unquoted field
# Email-ish
(?:[\w.+-]+)@((?:[\w-]+\.)+[a-z]{2,})
# group 1 = domain (non-capturing group inside)Выигрыш в производительности
Незахватывающие группы (?:...) немного быстрее и требуют меньше памяти, потому что движок не хранит захваченный текст. Выигрыш на одно совпадение мал, но заметен в плотных циклах по большим текстам. Используйте их, когда захваченное значение не нужно.
# Non-capturing groups are slightly faster
# They skip storing the matched text
# Microbenchmark concept (Python)
import re, time
text = "a" * 1000
# Capturing version
r1 = re.compile(r"(a)+")
# Non-capturing version
r2 = re.compile(r"(?:a)+")
# Both match same text, but r2 is marginally faster
# More importantly: avoids unnecessary group data
# Use non-capturing when you don't need group(N)
# In hot loops, this matters:
patterns = [
r"(?:\s*,\s*)", # non-capturing
r"(\s*,\s*)", # capturing (waste if unused)
]
# When extraction IS needed, use capturing:
re.findall(r"(\w+)@(\w+)", "a@b c@d") # need the captures
# When only matching matters, use non-capturing:
re.search(r"(?:\d{1,3}\.){3}\d{1,3}", text) # just match test
# Replace with no group reference
re.sub(r"(?:\s)+", "_", "a b c") # "a_b_c" (no groups used)Частые сценарии
Незахватывающие группы хороши для группировки альтернации, применения квантификаторов к подшаблонам, необязательных секций и чистоты номеров захвата. По умолчанию используйте (?:...) для группировки — и только () когда действительно нужно извлечь текст или сослаться на него.
# 1. Grouping for alternation
(?:cat|dog|bird)s? # plural animal names
\.(?:jpg|jpeg|png|gif)$ # image extensions
^(?:Mr|Mrs|Ms|Dr)\.\s # honorifics
# 2. Optional/required sub-patterns
https?://(?:www\.)? # protocol + optional www
\d{4}(?:-?\d{2}){2} # date with optional hyphens
# 3. Repeated complex sub-pattern
(?:\d{1,3}\.){3}\d{1,3} # IPv4
(?:\s*\d+\s*)+, # comma-separated numbers
# 4. Path-style patterns
(?:/[a-z][\w-]*)+ # URL path like /api/users/123
(?:\.\w+)+ # file.txt.bak (multiple extensions)
# 5. Quoted strings with escapes
"(?:[^"\\]|\\.)*" # double-quoted with escapes
# 6. Header parsing
^(\w+):\s*(.*)$ # name: value (just capture both)
# 7. Programming keyword + identifier
(?:const|let|var)\s+(\w+) # only capture the variable name
# 8. CSV with optional quotes
(?:^|,)(?:"([^"]*)"|([^,]*)) # capture quoted OR unquotedПросмотр вперёд и назад
Позитивный просмотр вперёд (?=)
Позитивный lookahead (?=...) утверждает, что дальше идёт совпадение с шаблоном, не потребляя символы. Полезен для поиска шаблонов только при определённом продолжении и для валидации вроде «должна быть цифра» в правилах паролей.
# (?=...) - matches if pattern follows, WITHOUT consuming
foo(?=bar) # "foo" only if followed by "bar"
\d+(?=px) # digits only if followed by "px"
\w+(?=@) # word chars only if followed by "@"
# Lookahead doesn't consume - the next match starts after "foo"
"foobar".match(/foo(?=bar)/) # match: "foo", index 0
# Next search continues at index 3, "bar" is still there
# Multiple lookaheads (all must match)
\d+(?=\s)(?=.*\bUSD\b) # digit followed by space AND USD somewhere
# Password: must contain a digit
^(?=.*\d).{8,}$ # at least 8 chars, contains a digit
# Word boundary alternative using lookahead
\w+(?=\W|$) # word chars until non-word or end
# Find numbers not followed by units
\d+(?!px)(?!em) # number not followed by px or em
# Capture inside lookahead
(\w+)(?=(\W)) # word + capture the following non-word charНегативный просмотр вперёд (?!)
Негативный lookahead (?!...) утверждает, что дальше НЕТ совпадения. Частые применения: исключение конкретных слов, отбраковка шаблонов (например, «пароль не должен содержать password») и совпадение только если дальше ничего нет (например, 'q' без следующей 'u').
# (?!...) - matches if pattern does NOT follow
foo(?!bar) # "foo" only if NOT followed by "bar"
\d+(?!px) # digits NOT followed by "px"
\w+(?!@\w) # word NOT followed by @word
# Q-w-o-T: find "q" not followed by "u"
q(?!u) # matches "q" in "Iraq" but not "quiet"
# Negative lookahead for "not this word"
\b(?!and\b|or\b|not\b)\w+ # any word except "and", "or", "not"
# Number NOT followed by decimal
\d+(?!\.\d) # "100" in "100 " but not in "100.5"
# Email local part: no consecutive dots
^(?!.*\.\.)[\w.]+@ # reject "a..b@..."
# Password: must NOT contain "password"
^(?!.*password).{8,}$ # 8+ chars, no "password" substring
# Disallow specific file extensions
\.\w+(?!\.(?:exe|bat|dll)$) # not an executable extension
# Find "cat" not preceded by "scat" (would need lookbehind)
# but here: cat not FOLLOWED by "s" or "egory"
\bcat(?!s|egory)\bПозитивный просмотр назад (?<=)
Позитивный lookbehind (?<=...) утверждает, что перед позицией идёт совпадение, не потребляя его. Используется, чтобы находить шаблоны только после чего-то конкретного. Многие движки (Java, старые PCRE, Python < 3.7) требуют lookbehind фиксированной длины; JS (ES2018+), .NET и новые PCRE допускают переменную.
# (?<=...) - matches if pattern PRECEDES (without consuming)
(?<=\$)\d+ # digits preceded by "$"
(?<=#)\w+ # word chars preceded by "#" (hex color)
(?<=Mr\.)\s\w+ # word after "Mr."
# Lookbehind doesn't consume - match starts AFTER the prefix
"$100".match(/(?<=\$)\d+/) # match: "100", index 2
# Get value after specific label
(?<=total:\s*)\d+\.\d{2} # number after "total:"
# Find text inside quotes
(?<=")[^"]+(?=") # content between double quotes
# Currency amount
(?<=USD\s)\d+(?:\.\d{2})? # number after "USD "
# Capture domain after @
(?<=@)[\w.]+ # domain part of email
# Path segment after /api/
(?<=/api/)[^/?#]+ # resource name in URL
# IMPORTANT: many engines require FIXED-LENGTH lookbehind
# (?<=ab|abc) -- INVALID in some engines (variable length)
# (?<=ab|cd) -- OK in most (same length alternatives)
# (?<=\w+) -- INVALID (variable length) in old engines
# JavaScript (ES2018+), .NET, and newer PCRE allow variable lengthНегативный просмотр назад (?<!)
Негативный lookbehind (?<!...) утверждает, что перед позицией НЕТ совпадения. Полезен для исключения совпадений по контексту: «найти числа без $ перед ними» или «найти слово, не являющееся частью большего идентификатора». Те же ограничения длины, что у позитивного lookbehind в старых движках.
# (?<!...) - matches if pattern does NOT precede
(?<!\$)\d+ # digits NOT preceded by "$"
(?<!\w)\w+ # word NOT preceded by word char (start of word)
(?<!Mr\.)\s\w+ # space+word NOT after "Mr."
# Find "cat" not preceded by "scat" or "concat"
(?<!s)cat\b # "cat" not preceded by "s" (matches "cat" alone)
# Number not preceded by a sign
(?<![-+])\d+ # unsigned numbers
# Word not after specific prefix
(?<!un)\w+ # word not preceded by "un"
# Currency validation
(?<!\d)\d{1,3}(?:,\d{3})*(?:\.\d{2})?(?!\d)
# number with thousand separators, not part of larger number
# Prevent matching substring inside larger identifier
(?<![_\w])count\b(?!er) # "count" not part of "counter"/"_count"
# Remove spaces NOT after periods
text.replace(/(?<!\.) +/g, " ")
# collapse double spaces unless after a period
# Find "and" not preceded by "&" (avoid matching "&" alone)
(?<!&)\b\w+\bШаблоны валидации
Lookahead отлично подходят для валидации: каждый проверяет одно правило с одной и той же стартовой позиции. Ставьте несколько lookahead в начало (^), чтобы задать составные правила вроде «пароль должен содержать заглавную, цифру, спецсимвол». Затем основной шаблон совпадает со всей строкой.
# Lookarounds are perfect for "must contain" / "must not contain"
# Password: 8+ chars, 1+ uppercase, 1+ lowercase, 1+ digit
^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{8,}$
# Stronger: also require special char
^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[^A-Za-z0-9]).{8,}$
# Must NOT contain "password" (case-insensitive)
^(?!.*password).{8,}$
# Email: must have @ and a dot after it
^(?=[^@]*@[^@]*\.[^@]*$).+$
# US phone: 10 digits possibly with separators
^(?=(?:\D*\d){10}\D*$)[\d\s()-]+$
# IPv4: 4 octets 0-255
^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)$
# Hex color: 3 or 6 hex digits, optional #
^#?(?:[0-9a-fA-F]{3}){1,2}$
# Date: YYYY-MM-DD with basic validation
^(?!0000)\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$
# Username: 3-20 chars, alphanumeric + underscore, not starting with digit
^(?=[A-Za-z_])[A-Za-z0-9_]{3,20}$Ограничения lookaround
Ограничения lookbehind: многие движки требуют шаблонов фиксированной длины (Python <3.7, Java, старые PCRE). Современные движки (JS ES2018+, .NET, Python 3.7+, PCRE 4.5+) допускают переменную длину. Lookaround имеют нулевую ширину — они не потребляют символы и не двигают курсор. Захватывающие группы внутри них ВСЁ РАВНО захватывают.
# 1. Lookbehind must be FIXED LENGTH in many engines
# Python (before 3.7), Java, older PCRE
(?<=abc|abcd)x # INVALID - alternatives of different lengths
(?<=abc|def)x # OK - same length
# Python 3.7+, JS (ES2018+), .NET, PCRE 4.5+ allow variable length
(?<=\w+)x # OK in modern engines
# 2. Lookbehind CANNOT be unbounded
(?<=.*)x # INVALID in most engines (no quantifier)
# 3. Capture groups inside lookaround
# DO capture, but the lookahead itself doesn't consume
(\w+)(?=(\W)) # group 1 = word, group 2 = next non-word
# 4. JavaScript lookbehind support (ES2018+)
# Old Safari versions don't support lookbehind
# Use capturing alternative for old browsers:
# Instead of (?<=\$)\d+, use \$(\d+) and use group 1
# 5. Lookarounds are zero-width
# They don't move the cursor
"abc".match(/(?=a)a/) # match: "a"
"abc".match(/(?=a)b/) # no match (can't be both a and b)
# 6. Nested lookarounds (legal but complex)
(?=(?:.*\d){3}).+ # must contain at least 3 digits
# 7. Performance: lookarounds can be slow with catastrophic patterns
(?=(a+)+)b # avoid nested quantifiers in lookaheadПодстановка и замена
Базовая замена
Синтаксис замены зависит от языка: JS использует string.replace(regex, str), Python — re.sub(pattern, repl, string), Java — String.replaceAll, PHP — preg_replace. Используйте глобальный флаг (g), чтобы заменить все совпадения; иначе заменится только первое.
# Replace in different languages
# JavaScript
"hello world".replace(/world/, "there") # "hello there"
"hello world".replace(/o/g, "0") # "hell0 w0rld"
# Python
import re
re.sub(r"world", "there", "hello world") # "hello there"
re.sub(r"o", "0", "hello world") # "hell0 w0rld"
# Java
"hello world".replaceAll("o", "0") # "hell0 w0rld"
# PHP
preg_replace('/o/', '0', 'hello world') # "hell0 w0rld"
# Replace first occurrence only
"hello world".replace(/o/, "0") # "hell0 world" (JS)
re.sub(r"o", "0", "hello world", count=1) # "hell0 world" (Py)
# Whole-match reference: $& (JS), $0 (Java/PHP), \g<0> (Py)
"abc".replace(/\w/g, "$&!") # "a!b!c!"
# Python: use a function
re.sub(r"\w", lambda m: m.group(0) + "!", "abc") # "a!b!c!"Замена с захваченными группами
Ссылайтесь на захваченные группы в замене: JS/Java используют $1, $2; Python — \1, \2 или \g<1> (предпочтительно); PHP допускает $1 или \1. Для всего совпадения используйте $& (JS) / $0 (Java) / \g<0> (Python). Чтобы вставить литеральный $ в замену в JS, пишите $$.
# Reference captured groups in replacement
# JavaScript: $1, $2, ... for groups; $& for whole match
"2024-01-15".replace(/(\d{4})-(\d{2})-(\d{2})/, "$3/$2/$1")
# Result: "15/01/2024"
# Swap two words
"hello world".replace(/(\w+) (\w+)/, "$2 $1") # "world hello"
# Python: \1, \2 OR \g<1>, \g<2> (preferred for clarity)
re.sub(r"(\d{4})-(\d{2})-(\d{2})", r"\3/\2/\1", "2024-01-15")
# Result: "15/01/2024"
# Java: $1, $2
"2024-01-15".replaceAll("(\d{4})-(\d{2})-(\d{2})", "$3/$2/$1")
# PHP: $1 or \1
preg_replace('/(\d{4})-(\d{2})-(\d{2})/', '$3/$2/$1', '2024-01-15')
# .NET: ${name} for named groups
# "John".Replace(...) uses ${first} if pattern is (?<first>\w+)
# Use $& (JS) or $0 (Java) for entire match
"hello".replace(/\w/g, "[$&]") # "[h][e][l][l][o]"
# Literal $ in replacement (JS) - use $$
"price".replace(/price/, "$$100") # "$100"Замена с именованными группами
Именованные группы в замене: JS использует $<name>, Python — \g<name>, Java/.NET — ${name}. PHP не поддерживает именованные ссылки в замене — используйте номера ($1, $2). Именованные замены куда читаемее, особенно для сложных шаблонов с множеством групп.
# Reference named capture groups in replacement
# JavaScript: $<name>
"2024-01-15".replace(
/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/,
"$<d>/$<m>/$<y>"
) # "15/01/2024"
# Python: \g<name>
re.sub(
r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})",
r"\g<d>/\g<m>/\g<y>",
"2024-01-15"
) # "15/01/2024"
# .NET: ${name}
Regex.Replace("2024-01-15",
@"(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})",
"${d}/${m}/${y}")
# PHP: \k<name> in pattern, but in replacement use \1 or $1
# (PHP doesn't directly support named backrefs in replacement)
preg_replace(
'/(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})/',
'$3/$2/$1', # use numbered refs
'2024-01-15'
)
# Java: ${name} (Java 7+)
"2024-01-15".replaceAll(
"(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})",
"${d}/${m}/${y}")
# Swap using named groups
"John Doe".replace(/(?<first>\w+) (?<last>\w+)/, "$<last>, $<first>")
# "Doe, John"Замена всех вхождений
Семантика замены всех вхождений различается: в JS нужен флаг /g (или replaceAll), re.sub в Python по умолчанию заменяет всё (count= ограничивает), Java replaceAll работает с regex и заменяет всё, а replace — буквально и всё, PHP preg_replace по умолчанию заменяет всё (ограничение — $limit). Всегда проверяйте, заменяет ли ваша функция только первое или все.
# Replace ALL matches - critical difference between languages
# JavaScript: needs /g flag for replaceAll behavior
"a-b-c".replace(/-/g, "+") # "a+b+c"
"a-b-c".replace(/-/, "+") # "a+b-c" (only first!)
# JavaScript: .replaceAll (ES2021+) requires /g flag
"a-b-c".replaceAll("-", "+") # "a+b+c" (string pattern)
"a-b-c".replaceAll(/-/g, "+") # "a+b+c" (regex needs /g)
# Python: re.sub replaces ALL by default
re.sub(r"-", "+", "a-b-c") # "a+b+c"
# Use count parameter for limited replacement
re.sub(r"-", "+", "a-b-c", count=1) # "a+b-c"
re.sub(r"-", "+", "a-b-c", count=2) # "a+b+c" wait, just first 2
# Java: replaceAll takes a regex
"a-b-c".replaceAll("-", "+") # "a+b+c"
# replaceFirst for just one
"a-b-c".replaceFirst("-", "+") # "a+b-c"
# Note: String.replace (no "All") does literal replace of ALL
"a-b-c".replace("-", "+") # "a+b+c" (literal, not regex)
# PHP: preg_replace replaces all by default
preg_replace('/-/', '+', 'a-b-c') # "a+b+c"
# Use $limit parameter
preg_replace('/-/', '+', 'a-b-c', 1) # "a+b-c"
# Go (noreplaceAll in regexp package)
re := regexp.MustCompile("-")
re.ReplaceAllString("a-b-c", "+") # "a+b+c"Замена функцией
Замена функцией позволяет динамические преобразования: смену регистра, арифметику, поиск по словарю. JS передаёт в функцию (match, groups, offset, string). Python передаёт объект match — используйте .group(n) для доступа к захватам. Java использует Matcher.appendReplacement; PHP — preg_replace_callback.
# Use a function for dynamic replacement (JS, Python)
# JavaScript: function receives (match, g1, g2, ..., offset, string)
"hello world".replace(/\w+/g, w => w.toUpperCase())
# "HELLO WORLD"
# Reverse each word
"hello world".replace(/\w+/g, w => w.split("").reverse().join(""))
# "olleh dlrow"
# Increment numbers
"a1 b2 c3".replace(/\d/g, d => parseInt(d) + 1)
# "a2 b3 c4"
# Python: function receives a match object
import re
re.sub(r"\w+", lambda m: m.group(0).upper(), "hello world")
# "HELLO WORLD"
# Use captured groups in Python function
def swap(m):
return f"{m.group(2)} {m.group(1)}"
re.sub(r"(\w+) (\w+)", swap, "hello world") # "world hello"
# Java: Matcher.appendReplacement with StringBuilder
Matcher m = Pattern.compile("\\d+").matcher("a1 b2");
StringBuilder sb = new StringBuilder();
while (m.find()) {
m.appendReplacement(sb, String.valueOf(Integer.parseInt(m.group()) + 10));
}
m.appendTail(sb); # "a11 b12"
# PHP: preg_replace_callback
preg_replace_callback('/\d+/', function($m) {
return $m[0] + 10;
}, 'a1 b2'); # "a11 b12"Частые шаблоны замены
Частые замены регулярками: обрезка пробелов, схлопывание пробелов, удаление HTML, смена регистра (kebab↔camel↔snake), маскирование чувствительных данных, форматирование чисел и телефонов, экранирование метасимволов. Во всех используются захватывающие группы и ссылки в замене для чистых декларативных преобразований.
# Trim leading/trailing whitespace
" hi ".replace(/^\s+|\s+$/g, "") # "hi"
# Collapse multiple spaces into one
"a b c".replace(/\s+/g, " ") # "a b c"
# Replace newlines with <br>
"text\nmore".replace(/\n/g, "<br>") # "text<br>more"
# Strip HTML tags
"<p>Hello</p>".replace(/<[^>]+>/g, "") # "Hello"
# Convert kebab-case to camelCase
"my-variable".replace(/-([a-z])/g, (_, c) => c.toUpperCase())
# "myVariable"
# CamelCase to snake_case
"myVar".replace(/([A-Z])/g, "_$1").toLowerCase()
# "my_var"
# Escape regex metacharacters
"1.5".replace(/[.*+?^${}()|[\]\\]/g, "\\$&") # "1\\.5"
# Mask emails: hide local part
"user@host".replace(/(^.).+(@.+)/, "$1***$2") # "u***@host"
# Format phone: 1234567890 -> 123-456-7890
"1234567890".replace(/(\d{3})(\d{3})(\d{4})/, "$1-$2-$3")
# URL-encode unsafe characters
"hello world".replace(/[^A-Za-z0-9]/g, c => "%" + c.charCodeAt(0).toString(16))
# "hello%20world"Флаги
Глобальный g
Флаг g (JS) заставляет match() и replace() работать со ВСЕМИ совпадениями, а не только с первым. Учтите: g делает regex stateful через lastIndex — повторное использование того же объекта между вызовами exec() может вызвать баги. Используйте matchAll (ES2020+) для более безопасного перебора. В Python — re.findall / re.finditer; в Java — replaceAll.
# g flag - match ALL occurrences, not just the first
# JavaScript
"abcabc".match(/a/g) # ["a", "a"] (all matches)
"abcabc".match(/a/) # ["a"] (first match only)
"a-b-c".replace(/-/g, "+") # "a+b+c"
# Without /g, replace() only does first match
"a-b-c".replace(/-/, "+") # "a+b-c"
# With /g, .match returns array of all matches (or null)
"aaa".match(/a/g) # ["a", "a", "a"]
# WARNING: /g with exec() maintains lastIndex state (gotcha)
const re = /a/g;
re.exec("aaa") # index 0, lastIndex=1
re.exec("aaa") # index 1, lastIndex=2
re.exec("aaa") # index 2, lastIndex=3
re.exec("aaa") # null, lastIndex=0 (resets)
# Use String.matchAll (ES2020+) for safer iteration
const matches = "aaa".matchAll(/a/g);
for (const m of matches) console.log(m.index);
# Python (re.sub finds all by default; re.findall)
re.findall(r"a", "aaa") # ["a", "a", "a"]
re.finditer(r"a", "aaa") # iterator of match objects
# Java: replaceAll = with /g; replaceFirst = without
# PHP: preg_match_all = with /g; preg_match = without
preg_match_all('/a/', 'aaa', $m) # finds allРегистронезависимый i
Флаг i делает сопоставление регистронезависимым. Используйте встроенный (?i) для локальной регистронезависимости (например, abc(?i)def делает независимым только 'def'). Большинство движков поддерживают (?i:...) для локальных флагов. Часто нужно для HTML-тегов, email и поиска без учёта регистра.
# i flag - ignore case
/abc/i.test("ABC") # true
/abc/i.test("AbC") # true
# Match HTML tags case-insensitively
/<div>/i.test("<DIV>") # true
text.replace(/<br\s*\/?>/gi, "\n") # <br>, <BR>, <Br/>
# Case-insensitive word match
"Hello hello HELLO".match(/hello/gi) # ["Hello", "hello", "HELLO"]
# Email is case-insensitive in practice
"[email protected]".match(/^[\w.+-]+@[\w.-]+\.[a-z]{2,}$/i)
# Python
re.search(r"abc", "ABC", re.IGNORECASE) # match
re.IGNORECASE # constant
re.I # shorthand
# Java
"ABC".matches("(?i)abc") # true (inline flag)
Pattern.compile("abc", Pattern.CASE_INSENSITIVE)
# Inline flags (most engines): (?i)
# (?i)abc == /abc/i
# abc(?i)def == abc plus case-insensitive def
# (?i:abc) == case-insensitive abc (PCRE/Java, scoped)
# PHP: '/abc/i'
preg_match('/abc/i', 'ABC') # 1 (match)
# Go (RE2): always use FlagI
re := regexp.MustCompile("(?i)abc")
re.MatchString("ABC") # true
# .NET
Regex.Match("ABC", "abc", RegexOptions.IgnoreCase)Многострочный m
Флаг m заставляет ^ и $ совпадать на границах каждой строки (по переводу строки), а не только в начале и конце строки. Полезен для построчной обработки. Встроенная форма — (?m). Учтите: m НЕ влияет на точку . — этим занимается флаг s (dotall).
# m flag - ^ and $ match start/end of EACH LINE (not just string)
# Without /m: ^ and $ are string-anchored
"line1\nline2".match(/^\w+/) # ["line1"] (only first line)
"line1\nline2".match(/^\w+/gm) # ["line1", "line2"] (each line)
# Find empty lines
"text\n\nmore".match(/^$/gm) # [""] (the empty line)
# Comment lines in code
"^#.*" with /gm finds all lines starting with #
# Process each line: replace leading whitespace
" a\n b\n c".replace(/^\s+/gm, "")
# "a\nb\nc"
# JavaScript
"hello\nworld".replace(/^/gm, "> ")
# "> hello\n> world"
# Python (re.MULTILINE)
re.findall(r"^\w+", "line1\nline2", re.MULTILINE)
# ["line1", "line2"]
re.M # shorthand
# Java: Pattern.MULTILINE
Pattern p = Pattern.compile("^\w+", Pattern.MULTILINE)
# Inline: (?m)
# (?m)^\w+ == with /m flag
# PHP: '/^\w+/m'
# Go: (?m) inline
# .NET: RegexOptions.Multiline
# IMPORTANT: m does NOT change . (use s flag for that)
# m affects ^ and $; s affects .Dotall s
Флаг s (dotAll) заставляет . совпадать и с переводом строки. ES2018+ в JS, re.DOTALL/re.S в Python, Pattern.DOTALL в Java. Что сбивает с толку, в .NET он называется 'Singleline'. Не зависит от флага m (multiline) — можно использовать оба. Переносимый вариант без /s: [\s\S] или [\d\D], чтобы совпасть с любым символом, включая перевод строки.
# s flag - dot . matches ALL chars INCLUDING newline
# Without /s: . doesn't match newline
"a\nb".match(/a.b/) # null
"a\nb".match(/a.b/s) # ["a\nb"] (with /s)
# Match anything between tags (even across lines)
"<div>a\nb</div>".match(/<div>(.*?)<\/div>/s)
# captures "a\nb"
# JavaScript (ES2018+) - s flag
const re = /<div>[\s\S]*?<\/div>/ # traditional
const re2 = /<div>.*?<\/div>/s # with /s
# Python: re.DOTALL or re.S
re.search(r"<div>.*?</div>", text, re.DOTALL)
# Inline: (?s)
# (?s). matches any char including newline
# Java: Pattern.DOTALL
Pattern.compile(".*?", Pattern.DOTALL)
# PHP: '/.*/s'
# Go: (?s) inline
# .NET: RegexOptions.Singleline
# Naming is confusing:
# - JavaScript "s" = "dotAll" (dot matches all)
# - .NET "Singleline" = same (dot matches all)
# - Multiline (m) and Singleline (s) are INDEPENDENT
# - You can use BOTH /ms simultaneously
# Combine m and s
"line1\nline2".replace(/^.*/gms, "X")
# replaces each line entirely with "X"
# Portable alternative (works everywhere): [\s\S] or [\d\D]
/.?[\s\S]*?</tag>/ # portable "any char"Unicode u
Флаг u (JS ES6+) трактует шаблоны как кодовые точки Unicode, исправляя проблемы суррогатных пар и включая экранирование свойств \p{...}. Python 3 по умолчанию Unicode (re.ASCII ограничивает). PHP использует /u для UTF-8. Без /u JS сопоставляет кодовые единицы UTF-16 — ломается работа с эмодзи и CJK.
# u flag - treat pattern as Unicode code points (not UTF-16 code units)
# JavaScript (ES6+)
# Without /u: matches UTF-16 code units (broken surrogate pairs)
"𝌆".length # 2 (surrogate pair)
/^.$/.test("𝌆") # false (two code units)
/^.$/u.test("𝌆") # true (one code point)
# Unicode property escapes (require /u)
/^\p{L}+$/u.test("Hello") # true (letters)
/\p{Script=Han}/u.test("中文") # true (CJK characters)
/\p{Emoji}/u.test("👋") # true
# Case-insensitive Unicode folding
/\w/iu.test("Ω") # true (Σ/σ/ς equivalence with /iu)
# Python 3: Unicode by default (use re.ASCII for ASCII-only)
re.search(r"\w+", "日本語") # matches (Unicode default)
re.search(r"\w+", "日本語", re.ASCII) # ASCII-only
# Python Unicode properties (3.13+ or regex module)
# \p{L} requires regex module or Python 3.13+
import regex # third-party module
regex.search(r"\p{L}+", "Hello")
# Java: Pattern.UNICODE_CHARACTER_CLASS
Pattern.compile("\\w+", Pattern.UNICODE_CHARACTER_CLASS)
# Java's \w is Unicode by default; flag enables POSIX Unicode classes
# PHP: /u flag for UTF-8 mode
preg_match('/^\p{L}+$/u', 'Hello') # 1 (Unicode)
# .NET: \p{L} works by default
# Go (RE2): \p{L} works by default
# IMPORTANT: with /u in JS, quantifiers apply to code points
/[😂]{2}/u.test("😂😂") # trueSticky y и расширенный x
Флаг sticky y (только JS) совпадает строго по lastIndex — полезно для парсеров и токенизаторов. Расширенный флаг x игнорирует неэкранированные пробелы и считает # началом комментария, позволяя многострочные задокументированные шаблоны. В Python — re.VERBOSE, в PHP/PCRE — /x, встроенная форма — (?x).
# y flag (sticky) - JS only - matches at lastIndex exactly
const re = /abc/y;
re.lastIndex = 0;
re.test("abcabc") # true, lastIndex now 3
re.test("abcabc") # true, lastIndex now 6 (matches at exactly 3)
re.test("abcabc") # false (would need to start at 6, no chars left)
# Useful for tokenizers (must match in sequence)
function tokenize(str) {
const tokens = [];
const ws = /\s*/y;
const num = /\d+/y;
const op = /[+\-*/]/y;
let pos = 0;
while (pos < str.length) {
ws.lastIndex = pos; let m = ws.exec(str);
if (m) pos = ws.lastIndex;
if (pos >= str.length) break;
num.lastIndex = pos; m = num.exec(str);
if (m) { tokens.push(["num", m[0]]); pos = num.lastIndex; continue; }
op.lastIndex = pos; m = op.exec(str);
if (m) { tokens.push(["op", m[0]]); pos = op.lastIndex; continue; }
throw new Error("Unexpected at " + pos);
}
return tokens;
}
# x flag (extended) - whitespace in pattern ignored, # starts comment
# JavaScript: ES2025+ proposal; widely supported in other engines
# Python (re.VERBOSE)
pattern = r"""
\d{4} # year
- # separator
\d{2} # month
- # separator
\d{2} # day
"""
re.match(pattern, "2024-01-15", re.VERBOSE)
# PHP: /x flag
preg_match('/
\d{4} # year
-
\d{2} # month
/x', '2024-01')
# Inline: (?x)
# (?x)\d{4}-\d{2} # comment allowed
# To match literal whitespace in /x mode, escape: \ or use [ ]
# \ \t\n all still work; just unescaped space/tab are ignoredЧастые шаблоны
Регулярка для email печально известна сложностью — полный шаблон RFC 5322 огромен. Большинство продакшен-кода использует упрощённый шаблон, который отсекает частые неверные варианты. Единственная настоящая проверка — отправить письмо со ссылкой подтверждения. Отклоняйте явно плохие форматы, но будьте снисходительны к пограничным случаям.
# Simplified email (good for most uses)
^[\w.+-]+@[\w.-]+\.[a-zA-Z]{2,}$
# More strict
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
# RFC 5322 (simplified - the actual RFC is much more complex)
^(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+
(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*)
@
(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+
[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$
# JavaScript
const emailRe = /^[\w.+-]+@[\w.-]+\.[a-zA-Z]{2,}$/;
emailRe.test("[email protected]") # true
emailRe.test("[email protected]") # true
# Python
import re
re.match(r"^[\w.+-]+@[\w.-]+\.[a-z]{2,}$", "[email protected]", re.I)
# Practical note: the only true validation is sending an email.
# Reject clearly invalid formats, but accept edge cases.
# Common TLD length: 2-24 chars (newer TLDs can be long)
^[\w.+-]+@[\w.-]+\.[a-zA-Z]{2,24}$URL
Регулярка URL бывает от простой (https?://...) до сложной по RFC. Для продакшена предпочитайте встроенный класс URL (JS) или urllib.parse (Python). Если используете regex, захватывайте scheme/host/port/path/query/fragment по отдельности для полного разбора. Домен: метки до 63 символов, TLD из 2+ букв.
# Basic URL pattern
^https?://[\w.-]+(?:\.[a-z]{2,})?(:\d+)?(?:/\S*)?$
# More complete URL parser
^(?:(\w+)://)? # 1: scheme
([^/:?#]+) # 2: host
(?::(\d+))? # 3: port
([^?#]*) # 4: path
(?:\?([^#]*))? # 5: query
(?:#(.*))? # 6: fragment
$
# JavaScript URL parsing
const urlRe = /^(https?):\/\/([^/:?#]+)(?::(\d+))?
([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/ix;
const m = "https://example.com:8080/path?q=1#top".match(urlRe);
// m[1]="https", m[2]="example.com", m[3]="8080",
// m[4]="/path", m[5]="q=1", m[6]="top"
# Python
import re
url_re = re.compile(r'''
^(?P<scheme>https?)://
(?P<host>[^/:?#]+)
(?::(?P<port>\d+))?
(?P<path>[^?#]*)
(?:\?(?P<query>[^#]*))?
(?:\#(?P<frag>.*))?
$''', re.VERBOSE | re.IGNORECASE)
# Match domain only
^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$
# Validate URL using built-in URL class (JS)
try { new URL(input); } catch { /* invalid */ }Номер телефона
Форматы телефонов сильно различаются по странам. США: 10 цифр с необязательными разделителями и кодом страны. Международный E.164: + и до 15 цифр. Для настоящей валидации сначала нормализуйте (уберите нецифры), затем проверяйте количество цифр и префикс. API и библиотеки телефонов надёжнее regex в продакшене.
# US phone: 123-456-7890, (123) 456-7890, 1234567890
^(?:\+1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$
# Capture components
^(?:\+1[-.\s]?)?\(?\(?(\d{3})\)?[-.\s]?(\d{3})[-.\s]?(\d{4})$
# International (E.164): +[country][number], max 15 digits
^\+[1-9]\d{1,14}$
# China phone: 11 digits starting with 1
^1[3-9]\d{9}$
# UK phone: 0XXXXXXXXXX or +44XXXXXXXXXX
^(?:0|\+44)\d{10}$
# Generic international (loose)
^\+?[\d\s().-]{7,}$
# JavaScript
const phoneRe = /^(?:\+1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$/;
phoneRe.test("(123) 456-7890") # true
phoneRe.test("123-456-7890") # true
phoneRe.test("1234567890") # true
# Python: extract phone from text
re.findall(r"\b\d{3}[-.]?\d{3}[-.]?\d{4}\b", text)
# Format phone: 1234567890 -> (123) 456-7890
"1234567890".replace(/(\d{3})(\d{3})(\d{4})/, "($1) $2-$3")IP-адрес
Regex для IPv4 использует альтернацию, чтобы ограничить каждый октет 0–255: 25[0-5] для 250–255, 2[0-4]\d для 200–249, 1?\d?\d для 0–199. IPv6 куда сложнее (с сокращением ::). Для определения приватных IP: 10.x, 172.16–31.x, 192.168.x. Используйте модуль ipaddress (Python) или net (JS) для надёжного разбора.
# IPv4: four octets 0-255
^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}
(?:25[0-5]|2[0-4]\d|1?\d?\d)$
# Explanation:
# 25[0-5] -> 250-255
# 2[0-4]\d -> 200-249
# 1?\d?\d -> 0-199 (1? optional leading 1, \d? optional tens)
# Python
import re
ipv4_re = re.compile(
r'^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)$'
)
ipv4_re.match("192.168.1.1") # match
ipv4_re.match("256.0.0.1") # None (256 > 255)
# Extract IPv4 from text
re.findall(r'\b(?:\d{1,3}\.){3}\d{1,3}\b', text)
# IPv6 (simplified)
^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$
# (:: shorthand, mixed notation are more complex)
# JavaScript
const ipv4 = /^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)$/;
ipv4.test("0.0.0.0") # true
ipv4.test("255.255.255.255") # true
ipv4.test("256.0.0.0") # false
# Convert IP to number
"192.168.1.1".split(".").reduce((acc, o) => (acc << 8) + +o, 0) >>> 0
# Private IP ranges
^(?:10\.|172\.(?:1[6-9]|2\d|3[01])\.|192\.168\.)Hex-цвет
Regex для hex-цвета: # и 3 или 6 hex-цифр. Используйте {3,6} осторожно (он допускает и 4, и 5). Лучше: (?:[0-9a-fA-F]{3}){1,2} строго требует ровно 3 или 6. Для 8-значного (RGBA) используйте [0-9a-fA-F]{3,4} или {8}. Цвета CSS могут быть hsl(), rgb(), именованными — для продакшена используйте CSS-парсер.
# Hex color: #RGB or #RRGGBB
^#?(?:[0-9a-fA-F]{3}){1,2}$
# Strict with #
^#(?:[0-9a-fA-F]{3}){1,2}$
# With optional alpha: #RGBA or #RRGGBBAA
^#(?:[0-9a-fA-F]{3,4}){1,2}$
# Capture RGB components
^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$
# JavaScript
const hexRe = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
hexRe.test("#fff") # true
hexRe.test("#FFAABB") # true
hexRe.test("#12AB56") # true
hexRe.test("#GGG") # false
hexRe.test("fff") # false (no #)
# Allow without #
const hexLoose = /^#?[0-9a-fA-F]{3}(?:[0-9a-fA-F]{3})?$/
# Extract hex colors from CSS
const css = "color: #fff; background: #123456;";
const colors = css.match(/#[0-9a-fA-F]{3,6}/g);
// ["#fff", "#123456"]
# Convert #RGB to #RRGGBB
"#abc".replace(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/i, "#$1$1$2$2$3$3")
// "#aabbcc"
# Python
import re
re.match(r"^#(?:[0-9a-fA-F]{3}){1,2}$", "#abc123")ZIP и почтовый индекс
Форматы почтовых индексов зависят от страны: ZIP в США — 5 цифр с необязательным +4; Канада — буква-цифра-буква, пробел, цифра-буква-цифра; индексы Великобритании сложны. Проверяйте по официальному формату страны. Для мультистрановых приложений выбирайте regex под каждую страну, а не один мега-шаблон.
# US ZIP: 12345 or 12345-6789
^\d{5}(?:-\d{4})?$
# Canada postal: A1A 1A1 (letter digit letter space digit letter digit)
^[A-Za-z]\d[A-Za-z][ -]?\d[A-Za-z]\d$
# UK postcode (simplified)
^[A-Z]{1,2}\d[A-Z\d]? ?\d[A-Z]{2}$
# China postal code: 6 digits
^\d{6}$
# Germany: 5 digits
^\d{5}$
# France: 5 digits
^\d{5}$
# Australia: 4 digits
^\d{4}$
# JavaScript
const zipRe = /^\d{5}(?:-\d{4})?$/;
zipRe.test("12345") # true
zipRe.test("12345-6789") # true
zipRe.test("1234") # false
# Canada postal
const caRe = /^[A-Za-z]\d[A-Za-z][ -]?\d[A-Za-z]\d$/;
caRe.test("M5V 2H1") # true
caRe.test("m5v2h1") # true
# Python
import re
re.match(r"^\d{5}(?:-\d{4})?$", "12345-6789") # match
# Format ZIP: 123456789 -> 12345-6789
"123456789".replace(/(\d{5})(\d{4})/, "$1-$2")Валидация пароля
Минимальная длина
Минимальная длина — важнейшее правило пароля. Современные рекомендации (NIST) советуют минимум 8 символов, поощряя длинные фразы (12–16+). Комбинируйте с lookahead для составных правил. Lookahead (?=.{8,}$) проверяет длину, не потребляя символы, что позволяет другим правилам тоже проверять с начала.
# At least 8 characters
^.{8,}$
# At least 12 characters (modern recommendation)
^.{12,}$
# Between 8 and 128 characters
^.{8,128}$
# Using lookahead (allows combining with other rules)
^(?=.{8,}$).*$
# JavaScript
const lenRe = /^.{8,}$/;
lenRe.test("short") # false
lenRe.test("longenough") # true
# Python
import re
bool(re.match(r"^.{8,}$", "longenough")) # True
# Allow any character including newlines (use s flag or [\s\S])
# /^.{8,}$/s matches multi-line password
# Common: 8+ with at least one of each type (lookaheads)
^(?=.{8,}$) # at least 8 chars
(?=.*[a-z]) # at least one lowercase
(?=.*[A-Z]) # at least one uppercase
(?=.*\d) # at least one digit
(?=.*[^A-Za-z0-9]) # at least one special char
.*$Требование заглавных
Требуйте заглавные через lookahead (?=.*[A-Z]). Для N заглавных букв: (?=(?:.*[A-Z]){N}). Для Unicode-заглавных (греческий, кириллица и т. д.) используйте \p{Lu} с флагом u (JS) или модуль regex (Python). Без lookahead просто проверяйте или считайте отдельно — код будет чище.
# Must contain at least one uppercase letter
^(?=.*[A-Z]).*$
# Must contain at least one uppercase, 8+ chars
^(?=.*[A-Z]).{8,}$
# At least two uppercase letters
^(?=(?:.*[A-Z]){2}).*$
# JavaScript
const upperRe = /^(?=.*[A-Z]).{8,}$/;
upperRe.test("password") # false (no uppercase)
upperRe.test("Password") # true
upperRe.test("PASSWORD") # true
# Python
import re
bool(re.match(r"^(?=.*[A-Z]).{8,}$", "Password1")) # True
# Count uppercase letters
const uppers = (pwd) => (pwd.match(/[A-Z]/g) || []).length;
uppers("PassWord") # 2
# Allow Unicode uppercase (with /u flag in JS)
const unicodeUpper = /^(?=.*\p{Lu}).+$/u;
unicodeUpper.test("Ωμέγα") # true (Ω is uppercase Greek)
# Python Unicode uppercase
re.search(r"\p{Lu}", "Ωμέγα", regex.UNICODE) # needs 'regex' module
# .NET: \p{Lu} for any uppercase letter
# Java: \p{Lu} works with Pattern.UNICODE_CHARACTER_CLASS
# Without lookahead: just count
if (/[A-Z]/.test(password)) { /* has uppercase */ }Требование цифры
Требуйте цифры через (?=.*\d). Для N цифр: (?=(?:.*\d){N}). \d по умолчанию совпадает с Unicode-цифрами — используйте [0-9] для ASCII. Многие считают отдельные вызовы test() понятнее стопки lookahead: каждое правило читается как одна булева проверка.
# Must contain at least one digit
^(?=.*\d).*$
# At least one digit, 8+ chars
^(?=.*\d).{8,}$
# At least three digits
^(?=(?:.*\d){3}).*$
# JavaScript
const digitRe = /^(?=.*\d).{8,}$/;
digitRe.test("password") # false (no digit)
digitRe.test("password1") # true
digitRe.test("pass1word2") # true
# Count digits
const digits = (pwd) => (pwd.match(/\d/g) || []).length;
digits("pass12word") # 2
# Python
import re
bool(re.match(r"^(?=.*\d).{8,}$", "password1")) # True
# Unicode digits (e.g., Arabic-Indic digits)
/^.*\p{N}/u.test("password١") # true (١ is Arabic-Indic 1)
# ASCII-only digits explicitly
^(?=.*[0-9]).*$
# Common password rule: must contain letter AND digit
^(?=.*[A-Za-z])(?=.*\d).{8,}$
# Alphanumeric only (no special chars)
^[A-Za-z0-9]{8,}$
# Without regex
const hasDigit = (s) => /\d/.test(s);
const hasLetter = (s) => /[A-Za-z]/.test(s);
if (hasDigit(pwd) && hasLetter(pwd) && pwd.length >= 8) { /* OK */ }Спецсимвол
Требуйте спецсимволы через (?=.*[^A-Za-z0-9]). Учтите: пробел считается спецсимволом — исключите его явно белым списком, если нужно. Многие сайты ограничивают набор безопасным белым списком (например, [!@#$%^&*]). Всегда проверяйте пробелы отдельно, если хотите их запретить.
# Must contain at least one special (non-alphanumeric) char
^(?=.*[^A-Za-z0-9]).*$
# Or explicit list of special chars
^(?=.*[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>/?]).*$
# At least one special, 8+ chars
^(?=.*[^A-Za-z0-9]).{8,}$
# JavaScript
const specialRe = /^(?=.*[^A-Za-z0-9]).{8,}$/;
specialRe.test("password") # false
specialRe.test("password!") # true
specialRe.test("pass word") # true (space is non-alphanumeric!)
# To exclude space from "special":
^(?=.*[!@#$%^&*\-_=+]).*$
# Python
import re
bool(re.match(r"^(?=.*[^A-Za-z0-9]).{8,}$", "Password1!")) # True
# Count special characters
const specials = (pwd) => (pwd.match(/[^A-Za-z0-9]/g) || []).length;
# Common allow-list for special chars in passwords
const ALLOWED_SPECIAL = /[!@#$%^&*\-_=+?]/;
const hasAllowedSpecial = (pwd) => ALLOWED_SPECIAL.test(pwd);
# Disallow whitespace entirely
^(?=\S*$).{8,}$ # no whitespace, 8+ chars
^(?!.*\s).{8,}$ # equivalent
# Without regex
const hasSpecial = (s) => /[^A-Za-z0-9]/.test(s);
const noWhitespace = (s) => !/\s/.test(s);Комбинированная валидация
Ставьте несколько lookahead в начало для составных правил: каждый проверяет одно условие с той же позиции. Для поддерживаемости отдельные вызовы test() могут быть понятнее одного мега-regex. Современные рекомендации NIST: приоритет длине (12+), разрешать все печатные символы и проверять по известным утёкшим паролям.
# Combined password rule:
# - 8+ chars
# - 1+ lowercase
# - 1+ uppercase
# - 1+ digit
# - 1+ special char
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^A-Za-z0-9]).{8,}$
# Stronger: 12+ chars, 2+ digits
^(?=.*[a-z])(?=.*[A-Z])(?=(?:.*\d){2})(?=.*[^A-Za-z0-9]).{12,}$
# JavaScript
const strongPwd = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^A-Za-z0-9]).{8,}$/;
strongPwd.test("Password1!") # true
strongPwd.test("password") # false (no upper, digit, special)
strongPwd.test("PASSWORD1!") # false (no lower)
# Python
import re
STRONG = re.compile(
r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^A-Za-z0-9]).{8,}$"
)
bool(STRONG.match("Password1!")) # True
# Readable alternative: separate checks (often clearer)
function validatePassword(pwd) {
const checks = {
length: pwd.length >= 8,
lower: /[a-z]/.test(pwd),
upper: /[A-Z]/.test(pwd),
digit: /\d/.test(pwd),
special: /[^A-Za-z0-9]/.test(pwd),
noWhitespace: !/\s/.test(pwd),
};
return Object.values(checks).every(Boolean) ? checks : null;
}
# Disallow common weak passwords
^(?!password|123456|qwerty|letmein).{8,}$
# NIST guidance: focus on length, allow all char types,
# check against breach databases (haveibeenpwned API)Сопоставление дат
YYYY-MM-DD
Regex может проверить формат (YYYY-MM-DD с месяцем 01–12 и днём 01–31), но НЕ смысловую корректность (30 февраля, високосные годы). Для настоящей валидации используйте Date (JS) или datetime (Python). Захватывающие группы позволяют извлечь год, месяц и день для дальнейшей обработки. Используйте ISO 8601 для однозначных дат.
# Basic: 4 digits, dash, 2 digits, dash, 2 digits
^\d{4}-\d{2}-\d{2}$
# With basic validation (month 01-12, day 01-31)
^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$
# Disallow year 0000
^(?!0000)\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$
# JavaScript
const dateRe = /^(?!0000)\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/;
dateRe.test("2024-01-15") # true
dateRe.test("2024-13-01") # false (month 13)
dateRe.test("2024-02-31") # true (regex doesn't know Feb has 28 days)
# Capture components
^(\d{4})-(\d{2})-(\d{2})$
"2024-01-15".match(/^(\d{4})-(\d{2})-(\d{2})$/)
// ["2024-01-15", "2024", "01", "15"]
# Python
import re
m = re.match(r"^(\d{4})-(\d{2})-(\d{2})$", "2024-01-15")
year, month, day = m.groups()
# Use Date for real validation
const d = new Date("2024-01-15");
if (isNaN(d.getTime())) { /* invalid */ }
# Python: datetime for real validation
from datetime import date
try: date(2024, 1, 15)
except ValueError: pass # invalidDD/MM/YYYY
DD/MM/YYYY (Европа) и MM/DD/YYYY (США) выглядят одинаково — неоднозначность реальная проблема. Для хранения и обмена всегда используйте ISO 8601 (YYYY-MM-DD). Regex захватывает день, месяц и год, чтобы переформатировать. Настоящая валидация (29 февраля, високосные годы, длины месяцев) требует библиотеки дат.
# DD/MM/YYYY with basic validation
^(?:0[1-9]|[12]\d|3[01])/(?:0[1-9]|1[0-2])/\d{4}$
# Capture day, month, year
^(\d{2})/(\d{2})/(\d{4})$
# With separators: / or - or .
^(\d{1,2})[/-](\d{1,2})[/-](\d{4})$
# JavaScript
const re = /^(\d{1,2})[/-](\d{1,2})[/-](\d{4})$/;
const m = "15/01/2024".match(re);
// m[1]="15", m[2]="01", m[3]="2024"
# US format MM/DD/YYYY
^(?:0[1-9]|1[0-2])/(?:0[1-9]|[12]\d|3[01])/\d{4}$
# Allow 1 or 2 digit day/month
^(\d{1,2})/(\d{1,2})/(\d{4})$
# Capture and reorder: DD/MM/YYYY -> YYYY-MM-DD
"15/01/2024".replace(/^(\d{2})\/(\d{2})\/(\d{4})$/, "$3-$2-$1")
// "2024-01-15"
# Python
import re
re.sub(r"^(\d{2})/(\d{2})/(\d{4})$", r"\3-\2-\1", "15/01/2024")
# "2024-01-15"
# Detect format ambiguity: 01/02/2024 - is it Jan 2 or Feb 1?
# Use ISO 8601 (YYYY-MM-DD) for unambiguous storageФормат времени
Regex времени: HH 00–23 (или 01–12 для 12-часового), MM/SS 00–59. Для часов используйте альтернацию ([01]\d|2[0-3]). Для хранения всегда используйте ISO 8601 (HH:MM:SS с необязательным часовым поясом). Для арифметики времени применяйте Date/datetime — regex проверяет только формат.
# 24-hour: HH:MM
^([01]\d|2[0-3]):[0-5]\d$
# 24-hour: HH:MM:SS
^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$
# 12-hour with AM/PM
^(0?[1-9]|1[0-2]):[0-5]\d(?:\s?[AP]M)?$
# Capture HH, MM, SS
^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$
# With milliseconds
^([01]\d|2[0-3]):[0-5]\d:[0-5]\d\.\d{3}$
# JavaScript
const time24 = /^([01]\d|2[0-3]):[0-5]\d$/;
time24.test("23:59") # true
time24.test("24:00") # false
time24.test("12:30") # true
const time12 = /^(0?[1-9]|1[0-2]):[0-5]\d\s?[AP]M$/i;
time12.test("1:30 PM") # true
time12.test("12:00am") # true
# Python
import re
re.match(r"^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$", "12:30:45")
# ISO 8601 duration: PT1H30M
^PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?$
# Time zone offset: +HH:MM or -HH:MM
[+-]([01]\d|2[0-3]):?[0-5]\d
# Combined date and time (ISO 8601)
^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:Z|[+-]\d{2}:?\d{2})?$ISO 8601 DateTime
ISO 8601 — международный стандарт даты и времени: YYYY-MM-DDTHH:MM:SS с необязательными долями секунды и часовым поясом (Z для UTC или ±HH:MM). Для продакшен-разбора используйте Date (JS) или datetime.fromisoformat (Python 3.7+). Regex — только для проверки формата.
# ISO 8601 date
^\d{4}-\d{2}-\d{2}$
# ISO 8601 date and time (basic)
^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:Z|[+-]\d{2}:\d{2})?$
# With optional milliseconds
^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})?$
# JavaScript - use built-in Date parsing
const d = new Date("2024-01-15T10:30:00Z");
if (!isNaN(d.getTime())) { /* valid ISO */ }
# Validate ISO 8601 strictly
const isoRe = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:\d{2})$/;
isoRe.test("2024-01-15T10:30:00Z") # true
isoRe.test("2024-01-15T10:30:00.123Z") # true
isoRe.test("2024-01-15T10:30:00+08:00") # true
isoRe.test("2024-01-15 10:30:00") # false (T required)
# Python - use datetime.fromisoformat (3.7+)
from datetime import datetime
try:
datetime.fromisoformat("2024-01-15T10:30:00")
except ValueError:
pass # invalid
# Capture date and time components
^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(Z|[+-]\d{2}:\d{2})?$
# Week date: 2024-W03-1 (year-week-weekday)
^\d{4}-W\d{2}-\d$
# Ordinal date: 2024-015 (year-day of year)
^\d{4}-\d{3}$Извлечение компонентов
Захватывающие группы позволяют извлечь компоненты даты для обработки. Именованные группы ((?P<name>...) в Python, (?<name>...) в JS) делают код куда читаемее числовых ссылок. Всегда преобразуйте месяц в целое и вычтите 1 для конструктора Date в JS (месяцы нумеруются с нуля).
# Capture year, month, day from YYYY-MM-DD
^(\d{4})-(\d{2})-(\d{2})$
# Groups: 1=year, 2=month, 3=day
# JavaScript
const m = "2024-01-15".match(/^(\d{4})-(\d{2})-(\d{2})$/);
const [_, year, month, day] = m;
// year="2024", month="01", day="15"
# Named groups (clearer)
const m2 = "2024-01-15".match(
/^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$)/
);
m2.groups.year // "2024"
m2.groups.month // "01"
m2.groups.day // "15"
# Python with named groups
import re
m = re.match(r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})",
"2024-01-15")
m.group("year") # "2024"
m.groupdict() # {"year": "2024", "month": "01", "day": "15"}
# Reformat date: YYYY-MM-DD -> DD/MM/YYYY
"2024-01-15".replace(
/^(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})$/,
"$<d>/$<m>/$<y>"
)
// "15/01/2024"
# Python
re.sub(r"(\d{4})-(\d{2})-(\d{2})", r"\3/\2/\1", "2024-01-15")
# "15/01/2024"
# Validate and extract date from text
const text = "Meeting on 2024-01-15 at 10:30";
const [_, y, mo, d] = text.match(/(\d{4})-(\d{2})-(\d{2})/);
// y="2024", mo="01", d="15"
# Convert to Date object
const d = new Date(+y, +mo - 1, +d); # months are 0-indexedСопоставление чисел
Целые числа
Regex целого: ^[+-]?\d+$ (знак необязателен). Для разделителей тысяч: ^\d{1,3}(?:,\d{3})*$ требует группы по три. Европейский формат использует точки или пробелы как разделители. Hex/octal/binary используют префиксы 0x/0o/0b (или просто 0 для восьмеричных в старых языках).
# Positive integers
^\d+$
# Optional sign
^[+-]?\d+$
# Negative only
^-\d+$
# With thousand separators (US/EU: comma)
^[+-]?\d{1,3}(?:,\d{3})*$
# JavaScript
const intRe = /^[+-]?\d+$/;
intRe.test("12345") # true
intRe.test("-1") # true
intRe.test("+42") # true
intRe.test("3.14") # false
# With commas
const commaInt = /^[+-]?\d{1,3}(?:,\d{3})*$/;
commaInt.test("1,234") # true
commaInt.test("12,345,678") # true
commaInt.test("1234") # false (needs comma)
# Allow comma-less too
^[+-]?(?:\d{1,3}(?:,\d{3})*|\d+)$
# Python
import re
re.match(r"^[+-]?\d+$", "12345") # match
# Strip commas before parsing
"1,234,567".replace(/,/g, "") # "1234567"
int("1,234,567".replace(",", "")) # 1234567
# Hex integer
^0x[0-9a-fA-F]+$
# Octal
^0o?[0-7]+$
# Binary
^0b[01]+$Десятичные числа
Regex десятичных требует аккуратности: допускаете ли вы точку в начале (.5)? точку в конце (1.)? необязательную целую часть? Частая форма: ^[+-]?\d+(?:\.\d+)?$ требует целую часть и необязательные дроби. Для валюты фиксируйте число знаков после точки (например, {2}).
# Basic decimal: digits.digits
^\d+\.\d+$
# Optional integer or fractional part
^\d+\.?\d*$ # 1, 1., 1.5
^\d*\.?\d+$ # .5, 1.5, 1
^\d+\.\d+|\d+$ # integer or decimal
# With optional sign
^[+-]?(?:\d+\.\d+|\d+)$
# JavaScript
const decRe = /^[+-]?(?:\d+\.\d+|\d+)$/;
decRe.test("3.14") # true
decRe.test("-0.5") # true
decRe.test("1") # true
decRe.test(".5") # false (requires leading digit)
# Allow leading dot
^[+-]?(?:\d+\.?\d*|\.\d+)$
# Fixed decimal places (e.g., 2)
^[+-]?\d+\.\d{2}$
# With thousand separators
^[+-]?\d{1,3}(?:,\d{3})*\.\d+$
# Avoid trailing dot
^[+-]?\d+(?:\.\d+)?$
# Extract decimals from text
"The price is 3.14 dollars".match(/-?\d+\.\d+/)
// ["3.14"]
# Python
import re
re.findall(r"-?\d+\.\d+", "Pi is 3.14, e is 2.72") # ['3.14', '2.72']
# Strict: 1-6 decimal places
^\d+\.\d{1,6}$Отрицательные числа
Regex отрицательного числа: ^-?\d+$ допускает необязательный минус. Для строго отрицательных: ^-\d+$. Осторожно при извлечении из текста — дефисы в 'co-operative' могут совпасть. Используйте границы слов (\b) или требуйте пробел перед минусом, чтобы избежать ложных срабатываний.
# Optional minus sign
^-?\d+$
# Optional + or -
^[+-]?\d+$
# Required minus
^-\d+$
# With decimal
^-?\d+\.\d+$
# JavaScript
const negRe = /^-?\d+$/;
negRe.test("-123") # true
negRe.test("123") # true (zero or one minus)
negRe.test("--1") # false
# Strict negative integer
const strictNeg = /^-\d+$/;
strictNeg.test("-1") # true
strictNeg.test("0") # false
strictNeg.test("-0") # true (technically -0)
# Exclude negative zero
^-(?!0+$)\d+$
# Allow scientific notation with sign
^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$
# Extract signed numbers from text
"Temperature: -5 to +10 degrees".match(/[+-]?\d+/g)
// ["-5", "+10"]
# Python
import re
re.findall(r"-?\d+", "loss: -100, gain: 50") # ['-100', '50']
# Avoid matching minus as text hyphen
# Use word boundary or whitespace before
\s-?\d+ # minus must follow whitespace
\b-?\d+\b # word boundary
# Currency with optional negative
^\$?-?\d+(?:\.\d{2})?$ # $-5.00 or -5.00 or $5.00Экспоненциальная запись
Экспоненциальная запись: мантисса (с необязательной дробью), 'e' или 'E', необязательный знак, цифры экспоненты. Для разбора используйте parseFloat (JS) или float (Python) — они понимают научную запись нативно. Захватывающие группы позволяют отдельно получить мантиссу и экспоненту.
# Scientific notation: mantissa e exponent
^[+-]?(?:\d+\.?\d*|\.\d+)[eE][+-]?\d+$
# Examples: 1e10, -2.5E-3, 6.022e23, 1.5E+10
# JavaScript
const sciRe = /^[+-]?(?:\d+\.?\d*|\.\d+)[eE][+-]?\d+$/;
sciRe.test("1e10") # true
sciRe.test("-2.5E-3") # true
sciRe.test("6.022e23") # true
sciRe.test("1.5E+10") # true
sciRe.test("1e") # false (no exponent)
# Allow integer or decimal without exponent too
^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$
# Capture mantissa and exponent
^([+-]?(?:\d+\.?\d*|\.\d+))[eE]([+-]?\d+)$
const m = "-2.5E-3".match(/^([+-]?(?:\d+\.?\d*|\.\d+))[eE]([+-]?\d+)$/);
// m[1]="-2.5" (mantissa), m[2]="-3" (exponent)
# Convert to number
parseFloat("6.022e23") # 6.022e+23
Number("1.5E+10") # 15000000000
# Python
import re
re.match(r"^[+-]?(?:\d+\.?\d*|\.\d+)[eE][+-]?\d+$", "-2.5E-3")
float("-2.5E-3") # -0.0025
# Extract scientific numbers from text
re.findall(r"[-+]?\d+\.?\d*[eE][-+]?\d+", "Avogadro: 6.022e23")
# ['6.022e23']
# Engineering notation (exponent multiple of 3)
# Hard to enforce via regex; better to validate after parsing
# Examples: 1.5e3, 2.5e6, 1e-3 (not 1.5e4)Формат валюты
Форматы валют различаются: США ($1,234.56), ЕС (1.234,56 €), Япония (¥1,234 без дробей). Для отображения используйте toLocaleString. Для разбора уберите символ валюты и разделители перед parseFloat. Regex проверяет формат; для продакшен-форматирования валют используйте Intl.NumberFormat.
# US currency: $123.45 or $1,234.56
^\$\d{1,3}(?:,\d{3})*\.\d{2}$
# Optional $ and cents
^\$?\d{1,3}(?:,\d{3})*(?:\.\d{2})?$
# Optional sign for negative
^[+-]?\$?\d{1,3}(?:,\d{3})*(?:\.\d{2})?$
# Allow negative after $: -$5.00 or $-5.00
^[+-]?\$[+-]?\d+(?:\.\d{2})?$
# European format: 1.234,56 €
^\d{1,3}(?:\.\d{3})*,\d{2}\s?€$
# JavaScript
const usd = /^\$\d{1,3}(?:,\d{3})*\.\d{2}$/;
usd.test("$1,234.56") # true
usd.test("$123.45") # true
usd.test("$1234.56") # false (needs comma)
usd.test("$1.234") # false (needs 2 decimals)
# Loose: just match dollar amount
/\$[\d,.]+/g
# Extract all currency from text
"Total: $1,234.56, tax: $99.99".match(/\$[\d,]+\.\d{2}/g)
// ["$1,234.56", "$99.99"]
# Parse to number
const parseUSD = (s) => parseFloat(s.replace(/[$,]/g, ""));
parseUSD("$1,234.56") # 1234.56
# Format number as currency
(1234.56).toLocaleString("en-US", { style: "currency", currency: "USD" })
// "$1,234.56"
# Python
import re
re.match(r"^\$\d{1,3}(?:,\d{3})*\.\d{2}$", "$1,234.56")
# Bitcoin: 0.5 BTC, satoshis
^\d+(?:\.\d{1,8})?\s?(?:BTC|sat|sats)$Замена строк
Простая замена
Замена первого или всех различается по языкам: replace() в JS без /g заменяет только первое; re.sub в Python по умолчанию заменяет всё (count=1 для первого); Java replaceFirst для первого, replaceAll для всех по regex, replace для всех буквальных. Используйте regex для шаблонов и буквальную замену строк для фиксированного текста.
# Replace first occurrence
# JavaScript
"hello world".replace(/world/, "there") # "hello there"
"hello world".replace(/o/, "0") # "hell0 world" (first only)
# Python
import re
re.sub(r"world", "there", "hello world") # "hello there"
re.sub(r"o", "0", "hello world", count=1) # "hell0 world" (first only)
# Java
"hello world".replaceFirst("o", "0") # "hell0 world"
"hello world".replace("world", "there") # literal, ALL occurrences
# PHP
preg_replace('/world/', 'there', 'hello world', 1) # limit 1
# Replace literal string (no regex)
"hello.world".replace(".", " ") # "hello world" (JS, literal)
"hello.world".replaceAll(".", " ") # "hello world" (JS, literal)
# Python: str.replace is literal
"hello.world".replace(".", " ") # "hello world"
# Replace using regex with special chars
"1.5".replace(/\./g, ",") # "1,5" (escape dot)
"1+2=3".replace(/\+/g, "-") # "1-2=3" (escape +)
# Chain replacements
" Hello World ".trim().replace(/\s+/g, "_").toLowerCase()
# "hello_world"
# Python chain
"_".join(" Hello World ".strip().split()).lower()
# "hello_world"Заменить всё
Поведение «заменить всё»: в JS нужен флаг /g с regex или replaceAll со строками; re.sub и str.replace в Python заменяют всё по умолчанию; replaceAll (regex) и replace (литерал) в Java делают всё; PHP preg_replace делает всё. Чтобы ограничить, используйте count (Python) или $limit (PHP).
# Replace ALL occurrences
# JavaScript: requires /g flag
"a-b-c-d".replace(/-/g, "+") # "a+b+c+d"
"a-b-c-d".split("-").join("+") # "a+b+c+d" (alternative)
# JavaScript: replaceAll (ES2021+)
"a-b-c-d".replaceAll("-", "+") # "a+b+c+d" (string, not regex)
"a-b-c-d".replaceAll(/-/g, "+") # needs /g flag with regex
# Python: re.sub does all by default
import re
re.sub(r"-", "+", "a-b-c-d") # "a+b+c+d"
# Python: str.replace also does all
"a-b-c-d".replace("-", "+") # "a+b+c+d" (literal)
# Java
"a-b-c-d".replaceAll("-", "+") # regex, all
"a-b-c-d".replace("-", "+") # literal, all
# PHP
preg_replace('/-/', '+', 'a-b-c-d') # all
# Go
regexp.MustCompile("-").ReplaceAllString("a-b-c-d", "+") # "a+b+c+d"
# Count occurrences
const count = (s, re) => (s.match(re) || []).length;
count("a-b-c-d", /-/g) # 3
# Replace with limit (Python, PHP)
re.sub(r"-", "+", "a-b-c-d", count=2) # "a+b+c-d"
preg_replace('/-/', '+', 'a-b-c-d', 2) # "a+b+c-d"
# Global case-insensitive replace
"Hello hello HELLO".replace(/hello/gi, "hi") # "hi hi hi"Захватывающие группы в замене
Ссылайтесь на захваченные группы в замене: JS/Java используют $1, $2 (и $& для всего совпадения); Python — \1, \2 или \g<1> (предпочтительно, избегает неоднозначности с \10+); PHP допускает $1 или \1. Для всего совпадения: $& (JS) / $0 (Java) / \g<0> (Python). Экранируйте литеральный $ как $$ в JS.
# Use captured groups in replacement
# Swap two words
"hello world".replace(/^(\w+) (\w+)$/, "$2 $1") # "world hello"
# Reformat date
"2024-01-15".replace(/(\d{4})-(\d{2})-(\d{2})/, "$3/$2/$1")
# "15/01/2024"
# Wrap matches
"hello".replace(/\w+/g, "[$&]") # "[hello]"
"hello world".replace(/\w+/g, "[$&]") # "[hello] [world]"
# Duplicate matches
"abc".replace(/(\w)/g, "$1$1") # "aabbcc"
# Conditional-like behavior with alternation
"Mr Smith".replace(/(Mr|Ms|Mrs) (\w+)/, "$2, $1.")
# "Smith, Mr."
# Python: \1, \2 or \g<1>, \g<2> (preferred)
import re
re.sub(r"(\d{4})-(\d{2})-(\d{2})", r"\3/\2/\1", "2024-01-15")
# "15/01/2024"
re.sub(r"(\w+)", r"[\1]", "hello") # "[hello]"
# Use named groups
"2024-01-15".replace(
/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/,
"$<d>/$<m>/$<y>"
) # "15/01/2024"
# Python named
re.sub(
r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})",
r"\g<d>/\g<m>/\g<y>",
"2024-01-15"
)
# Reference whole match: $& (JS), $0 (Java), \g<0> (Python)
"abc".replace(/\w/g, "[$&]") # "[a][b][c]"
re.sub(r"\w", r"[\g<0>]", "abc") # "[a][b][c]"
# Literal $ in replacement (JS): use $$
"price".replace(/price/, "$$100") # "$100"Смена регистра
Смена регистра через regex и замену функцией: title case (заглавная в каждом слове), преобразования camelCase↔snake_case↔kebab-case используют захватывающие группы и toUpperCase/toLowerCase. В Python для того же применяют lambda-функции. Шаблон ([A-Z]), захваченный перед заменой, — ключ к преобразованиям стилей регистра.
# Capitalize first letter of each word (title case)
"hello world".replace(/\b\w/g, c => c.toUpperCase())
# "Hello World"
# Capitalize first letter of string only
"hello world".replace(/^\w/, c => c.toUpperCase())
# "Hello world"
# Lowercase first letter, rest unchanged
"HelloWorld".replace(/^\w/, c => c.toLowerCase())
# "helloWorld"
# camelCase to snake_case
"myVariableName".replace(/([A-Z])/g, "_$1").toLowerCase()
# "my_variable_name"
# snake_case to camelCase
"my_variable_name".replace(/_([a-z])/g, (_, c) => c.toUpperCase())
# "myVariableName"
# kebab-case to camelCase
"my-variable-name".replace(/-([a-z])/g, (_, c) => c.toUpperCase())
# "myVariableName"
# camelCase to kebab-case
"myVariableName".replace(/([A-Z])/g, "-$1").toLowerCase()
# "my-variable-name"
# UPPER_CASE to lowerCase
"MY_VAR_NAME".replace(/_/g, "").toLowerCase()
# "myvarname" (without proper conversion)
# Constant case to camelCase
"MY_VAR_NAME".toLowerCase().replace(/_([a-z])/g, (_, c) => c.toUpperCase())
# "myVarName"
# Sentence case: capitalize first letter of each sentence
"hello. world. foo.".replace(/(^|\.\s+)([a-z])/g, (_, p, c) => p + c.toUpperCase())
# "Hello. World. Foo."
# Python equivalents
import re
re.sub(r"\b\w", lambda m: m.group().upper(), "hello world")
# "Hello World"
re.sub(r"([A-Z])", r"_\1", "myVar").lower()
# "my_var"Обрезка и очистка
Частая очистка: trim (используйте встроенный .trim() в JS, .strip() в Python — быстрее), схлопывание нескольких пробелов (\s+ -> один пробел), нормализация переводов строк (CRLF/CR -> LF), удаление комментариев. Используйте многострочный флаг (/m) при построчных операциях вроде удаления пробелов в конце каждой строки.
# Trim leading and trailing whitespace
" hi ".replace(/^\s+|\s+$/g, "") # "hi"
# Note: JS String.prototype.trim() is preferred: " hi ".trim()
# Trim leading only
" hi ".replace(/^\s+/, "") # "hi "
# Or: " hi ".replace(/^\s+/g, "")
# Trim trailing only
" hi ".replace(/\s+$/, "") # " hi"
# Collapse multiple spaces into one
"a b c".replace(/\s+/g, " ") # "a b c"
# Collapse but preserve newlines
"a b
c".replace(/[ \t]+/g, " ").replace(/\n{2,}/g, "\n")
# "a b
c"
# Remove all whitespace
"a b c".replace(/\s/g, "") # "abc"
"a b c".replace(/\s+/g, "") # "abc"
# Remove blank lines
"text\n\n\nmore".replace(/^\s*$(?:\n|$)/gm, "")
# "text
more"
# Normalize line endings
"text\r\nmore".replace(/\r\n/g, "\n") # CRLF -> LF
"text\rmore".replace(/\r/g, "\n") # CR -> LF
# Remove trailing whitespace from each line
"text \nmore ".replace(/\s+$/gm, "")
# "text
more"
# Strip comments (/* */ and //)
code.replace(/\/\*[\s\S]*?\*\//g, "") # block comments
code.replace(/\/\/.*$/gm, "") # line comments
# Python equivalents
import re
re.sub(r"^\s+|\s+$", "", " hi ") # "hi"
re.sub(r"\s+", " ", "a b c") # "a b c"
re.sub(r"\s+$", "", "a ", flags=re.M) # trim trailing per lineУдаление HTML-тегов
Удаляйте HTML-теги через /<[^>]+>/g (наивно, но работает для простых случаев). Удаляйте <script>/<style> вместе с содержимым ленивым [\s\S]*?. Для настоящего HTML используйте парсер (DOM в JS, BeautifulSoup в Python) — regex ломается на вложенных тегах, атрибутах с > и некорректном HTML. Декодируйте сущности через DOM или html.unescape (Python).
# Naive: remove anything between < and >
"<p>Hello</p>".replace(/<[^>]+>/g, "") # "Hello"
# Strip all tags but keep content
"<div><p>Hello <b>world</b></p></div>".replace(/<[^>]+>/g, "")
# "Hello world"
# Remove specific tag
"<div>keep</div>".replace(/<\/?div>/g, "") # "keep"
# Remove script and style blocks (with content)
html.replace(/<script[\s\S]*?<\/script>/gi, "")
html.replace(/<style[\s\S]*?<\/style>/gi, "")
# Decode basic HTML entities
"AT&T".replace(/&/g, "&")
"<tag>".replace(/</g, "<").replace(/>/g, ">")
" ".replace(/ /g, " ")
""".replace(/"/g, '\"')
# Decode all entities via DOM (JS)
function decodeEntities(s) {
const t = document.createElement("textarea");
t.innerHTML = s;
return t.value;
}
# Remove attributes from tags
'<a href="x" class="y">link</a>'.replace(/(<\w+)[^>]*>/g, "$1>")
# "<a>link</a>" (but the </a> stays; need to handle closing too)
# Self-closing tags
html.replace(/<\w+[^>]*/>/g, "")
# Strip HTML comments
html.replace(/<!--[\s\S]*?-->/g, "")
# Python
import re
re.sub(r"<[^>]+>", "", "<p>Hello</p>") # "Hello"
re.sub(r"<script[\s\S]*?</script>", "", html, flags=re.I)
# WARNING: regex is fragile for HTML parsing.
# Use DOMParser (JS) or BeautifulSoup (Python) for real HTML.Извлечение и разбиение
Извлечь первое совпадение
Извлечение первого совпадения: JS String.match() возвращает массив (или null), Python re.search возвращает объект Match (или None), Java Matcher.find() переходит к следующему совпадению, PHP preg_match заполняет массив группами. Используйте search (Python), когда шаблон может быть где угодно, — match привязан к началу.
# Extract first match
# JavaScript
const m = "price: $42.50, tax: $3.00".match(/\$(\d+\.\d{2})/);
// m[0] = "$42.50", m[1] = "42.50"
if (m) console.log(m[1]); // "42.50"
# Python
import re
m = re.search(r"\$(\d+\.\d{2})", "price: $42.50, tax: $3.00")
if m:
print(m.group(1)) # "42.50"
# Java
Matcher m = Pattern.compile("\\$(\\d+\\.\\d{2})")
.matcher("price: $42.50");
if (m.find()) { String price = m.group(1); }
# PHP
if (preg_match('/\$(\d+\.\d{2})/', 'price: $42.50', $m)) {
echo $m[1]; // "42.50"
}
# Extract with named groups
const m2 = "2024-01-15".match(
/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
);
if (m2) console.log(m2.groups.year); // "2024"
# Test if pattern exists (no extraction needed)
const has = /\d{4}-\d{2}-\d{2}/.test("date: 2024-01-15"); // true
# Python: search vs match vs fullmatch
re.search(r"abc", "xabcx") # finds anywhere
re.match(r"abc", "abcx") # anchored at start
re.fullmatch(r"abc", "abc") # entire stringИзвлечь все совпадения
Извлечение всех совпадений: match() в JS с /g возвращает плоский массив совпадений (без деталей групп); matchAll (ES2020+) возвращает итератор с полной информацией. re.findall в Python возвращает список групп (или совпадений целиком, если групп нет). Для ленивого перебора большого текста используйте re.finditer.
# Extract ALL matches
# JavaScript: with /g flag, match() returns array of matches (no groups)
"1a2b3c".match(/\d/g) # ["1", "2", "3"]
"a1 b2 c3".match(/\d+/g) # ["1", "2", "3"]
# matchAll (ES2020+) returns iterator with full match info
const matches = [..."2024-01-15 2025-02-20".matchAll(/(\d{4})-(\d{2})-(\d{2})/g)];
// matches[0][0]="2024-01-15", matches[0][1]="2024", ...
# Python: re.findall returns list of group(s)
import re
re.findall(r"\d+", "a1 b2 c3") # ["1", "2", "3"]
re.findall(r"(\d+)-(\d+)", "12-34 56-78") # [("12","34"), ("56","78")]
# Note: if groups present, returns tuples of groups, not whole match
# Use (?:...) or non-capturing to get whole match
re.findall(r"\d+-\d+", "12-34 56-78") # ["12-34", "56-78"]
# re.finditer returns match objects (lazy iterator)
for m in re.finditer(r"\d+", "a1 b2 c3"):
print(m.group(), m.start(), m.end())
# Java: Matcher.find() in loop
Matcher m = Pattern.compile("\\d+").matcher("a1 b2 c3");
while (m.find()) { System.out.println(m.group()); }
# PHP: preg_match_all fills multidimensional array
preg_match_all('/\d+/', 'a1 b2 c3', $m, PREG_SET_ORDER);
// $m[0][0] = "1", $m[1][0] = "2", ...
# Count matches
(len("a1 b2 c3".match(/\d/g) || [])) # 3 (JS)
len(re.findall(r"\d", "a1 b2 c3")) # 3 (Python)Разбиение строки
Разбиение строк regex: JS String.split(regex), Python re.split, Java String.split, PHP preg_split, Go regexp.Split. Захватывающие группы в шаблоне сохраняют разделители в массиве результата. Используйте limit/maxsplit, чтобы ограничить число разбиений. Разбиение по пробелам: /\s+/ обрабатывает несколько пробелов, табы, переводы строк.
# Split string by pattern
# JavaScript
"a,b,c".split(",") # ["a", "b", "c"]
"a, b , c".split(/\s*,\s*/) # ["a", "b", "c"] (trim around comma)
"1-2-3".split("-") # ["1", "2", "3"]
# Split with capture group keeps the delimiter
"a1b2c3".split(/(\d)/) # ["a", "1", "b", "2", "c", "3", ""]
# Limit splits
"a,b,c,d".split(",", 2) # ["a", "b"] (rest in last element)
"a,b,c,d".split(/,/, 2) # ["a", "b"]
# Python
import re
re.split(r"\s*,\s*", "a, b , c") # ["a", "b", "c"]
re.split(r"(\d)", "a1b2c3") # ["a", "1", "b", "2", "c", "3", ""]
re.split(r",", "a,b,c", maxsplit=1) # ["a", "b,c"]
# Java
"a,b,c".split(",") # ["a", "b", "c"]
"a, b , c".split("\\s*,\\s*") # ["a", "b", "c"]
"a,b,c,d".split(",", 2) # ["a", "b,c,d"]
# PHP
preg_split('/\s*,\s*/', 'a, b , c') # ["a", "b", "c"]
preg_split('/(\d)/', 'a1b2c3', -1, PREG_SPLIT_DELIM_CAPTURE)
# Go
regexp.MustCompile("\\s*,\\s*").Split("a, b , c", -1)
# Split on whitespace (any)
"a b\tc\nd".split(/\s+/) # ["a", "b", "c", "d"]
# Split lines
"line1\nline2\r\nline3".split(/\r\n|\r|\n/) # ["line1", "line2", "line3"]Извлечение пар ключ-значение
Извлекайте пары key=value шаблоном вроде (\w+)\s*[=:]\s*([^,;\n]+). Object.fromEntries + matchAll (JS) или dict + findall (Python) собирают чистый объект. Для настоящих query-строк URL и HTTP-заголовков предпочитайте встроенные URL/URLSearchParams (JS) или urllib.parse (Python) — они корректно работают с URL-кодированием.
# Extract key=value pairs
# Match key=value (or key: value)
(\w+)\s*[=:]\s*([^,;\n]+)
# JavaScript
const text = "name=Alice, age=30; city: NYC";
const pairs = [...text.matchAll(/(\w+)\s*[=:]\s*([^,;\n]+)/g)];
const obj = Object.fromEntries(pairs.map(m => [m[1], m[2].trim()]));
// { name: "Alice", age: "30", city: "NYC" }
# Python
import re
text = "name=Alice, age=30; city: NYC"
pairs = re.findall(r"(\w+)\s*[=:]\s*([^,;\n]+)", text)
dict(pairs) # {"name": "Alice", "age": "30", "city": "NYC"}
# URL query string parsing
"?a=1&b=2&c=3".match(/[?&]([^=]+)=([^&]+)/g)
// ["?a=1", "&b=2", "&c=3"]
# Parse query string into object
const qs = "a=1&b=2&c=hello%20world";
const params = Object.fromEntries(
[...qs.matchAll(/([^=&]+)=([^&]*)/g)]
.map(m => [m[1], decodeURIComponent(m[2])])
);
// { a: "1", b: "2", c: "hello world" }
# Python equivalent
from urllib.parse import parse_qs
parse_qs("a=1&b=2&c=hello%20world")
# {"a": ["1"], "b": ["2"], "c": ["hello world"]}
# HTTP header parsing
const headers = "Content-Type: text/html\nAccept: */*";
const headerObj = Object.fromEntries(
[...headers.matchAll(/^(\w[\w-]*):\s*(.+)$/gm)]
.map(m => [m[1], m[2]])
);
// { "Content-Type": "text/html", "Accept": "*/*" }Токенизация
Токенизация разбивает текст на смысловые единицы: слова (\w+), числа, строки, операторы, пунктуацию. Используйте альтернацию с захватывающими группами для шаблонов токенизатора. re.finditer в Python даёт объекты совпадений с позициями. Для настоящей NLP-токенизации используйте библиотеки вроде NLTK или spaCy — они обрабатывают пограничные случаи, недоступные regex.
# Tokenize: split text into tokens (words, numbers, punctuation)
# Simple word tokenization
\w+ # sequences of word chars
"Hello, world! 42".match(/\w+/g) # ["Hello", "world", "42"]
# Tokenize keeping punctuation
/[A-Za-z0-9]+|[^\sA-Za-z0-9]/g
"Hello, world!".match(/[A-Za-z0-9]+|[^\sA-Za-z0-9]/g)
# ["Hello", ",", "world", "!"]
# Number tokens
/\d+\.?\d*|\.[0-9]+/
"Price 3.14 and .5".match(/\d+\.?\d*|\.[0-9]+/g) # ["3.14", ".5"]
# String literals
/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/
# Programming language tokens (simplified)
const tokens = source.matchAll(
/(?<comment>\/\/.*$|\/\*[\s\S]*?\*\/)
|(?<string>"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')
|(?<number>\d+\.?\d*)
|(?<ident>[A-Za-z_]\w*)
|(?<op>[+\-*/=<>!&|]+)
|(?<punct>[(){}[\];,.])/gx
);
# Split into words preserving position
import re
for m in re.finditer(r"\w+", "Hello world foo"):
print(m.group(), m.start(), m.end())
# Sentence tokenization (simplified)
text.split(/(?<=[.!?])\s+/)
# Splits on whitespace after . ! or ?
# Whitespace tokenization (preserves tokens)
text.split(/(\s+)/) # keeps whitespace as separate elementsЖадность и ленивость
Жадность по умолчанию
Жадные квантификаторы захватывают максимум, затем откатываются, чтобы остальная часть шаблона совпала. Это часто даёт неожиданные совпадения, как в HTML: <.+> захватывает целый <b>...</b><i>...</i> как одно. Используйте ленивые квантификаторы или конкретные классы символов, чтобы этого избежать.
# Quantifiers are GREEDY by default - match as much as possible
# * + ? {n,m} all greedy
# Greedy: .* takes everything, then backtracks
"<a> <b> <c>".match(/<.*>/) # ["<a> <b> <c>"] (whole thing!)
# Greedy backtracking example
"12345".match(/\d+\d/) # \d+ takes "1234", last \d takes "5"
# Greedy with anchored end - takes everything then backtracks to find end
"hello world end".match(/^.*(end).*$/) # captures "end"
# Common greedy patterns
.* # entire line (zero or more)
.+ # entire line (one or more)
\d+ # all consecutive digits
\w+ # all consecutive word chars
\s+ # all consecutive whitespace
# HTML gotcha: greedy matches too much
"<b>bold</b> and <i>italic</i>".match(/<.+>/)
# ["<b>bold</b> and <i>italic</i>"] - WRONG, matches across tags!
# Greedy on alternation
"cat or dog".match(/cat|cat dog/) # ["cat"] - first alternative wins
# Email greedy
"a@b@c".match(/.+@.+/) # ["a@b@c"] - greedy .+ takes "a@b"Ленивые квантификаторы
Ленивые квантификаторы (*? +? ??) совпадают с минимумом. Используйте их для кратчайшего совпадения между разделителями: <.*?> для HTML-тегов, ".*?" для строк в кавычках. Для простых строк в кавычках '[^']*' обычно быстрее и понятнее, чем '.*?'.
# Add ? after a quantifier to make it LAZY (non-greedy)
# Lazy: match as LITTLE as possible, expand only if needed
# Lazy quantifiers
*? # lazy zero or more
+? # lazy one or more
?? # lazy zero or one
{n,m}? # lazy range
# Lazy: stops at FIRST closing tag
"<a> <b> <c>".match(/<.*?>/) # ["<a>"] - just the first tag
"<b>bold</b> <i>italic</i>".match(/<.+?>/)
# ["<b>"] - just the first opening tag
# Find quoted strings
'"a" and "b"'.match(/".*?"/g) # ['"a"', '"b"']
'"a" and "b"'.match(/".*"/g) # ['"a" and "b"'] (greedy wrong!)
# Capture content between tags
"<div>hello</div>".match(/<div>(.*?)<\/div>/) # captures "hello"
# Lazy vs negated class (often faster alternative)
# These are equivalent but negated class is usually faster:
'"hello"'.match(/"[^"]*"/) # uses negated class - preferred
'"hello"'.match(/".*?"/) # uses lazy - works but slower
# Multiple lazy quantifiers
'(.*?)(.*?)(.*?)' # all lazy, but each expands as needed
# When greedy fails, lazy often helps
# Match XML comments <!-- ... -->
text.match(/<!--[\s\S]*?-->/g) # lazy: stops at first -->Частые ленивые шаблоны
Частые ленивые шаблоны: содержимое тега (<tag>(.*?)</tag>), строки в кавычках ('[^']*'), содержимое в скобках, комментарии. Для содержимого между разделителями предпочитайте отрицательные классы ([^']*) ленивым квантификаторам (.*?) — они понятнее и часто быстрее. Ленивость реально выигрывает, когда разделитель состоит из нескольких символов.
# Most common lazy patterns
# Content between tags (HTML/XML)
<([a-z][a-z0-9]*)\b[^>]*>(.*?)<\/\1>
# captures tag name and inner content (lazy)
# Quoted strings
"([^"]*)" # double-quoted (preferred over ".*?")
'([^']*)' # single-quoted
# Bracketed content
\[([^\]]*)\] # content inside [ ]
\(([^()]*)\) # content inside ( )
\{([^{}]*)\} # content inside { }
# Comments
/\*[\s\S]*?\*/ # C-style block comment
<!--.*?--> # HTML comment (with /s for multiline)
# URL in text
https?://\S+?["'\s<>] # URL until delimiter
# Path components
/([^/]+) # one path segment
# Code block in markdown
\`\`\`([\s\S]*?)\`\`\` # fenced code block
# Lazy with anchors for validation
^.*?\bword\b.*$ # line containing "word" (lazy doesn't matter here)
# Variable assignment
(\w+)\s*=\s*("[^"]*"|'[^']*'|\d+)Когда что использовать
Выбирайте жадность, когда нужен самый длинный вариант (до последнего разделителя) или конец уникален. Выбирайте ленивость, когда разделителей несколько или нужно каждое совпадение отдельно. Лучше всего — конкретные классы символов ([^"/]*) чтобы вообще избежать проблемы: они обычно понятнее и быстрее ленивых квантификаторов.
# Use GREEDY when:
# - You want the longest possible match
# - The end is uniquely identified
# - You want to capture until the LAST occurrence
# Capture everything to the last occurrence of X
^.*X # greedy: matches up to the LAST X
"everything;until;last;semicolon".match(/^.*;/) # "everything;until;last;"
# Use LAZY when:
# - You want the shortest match
# - Multiple delimiters exist
# - You want to match each occurrence separately
# Match each quoted string
'"a","b","c"'.match(/"[^"]*"/g) # ['"a"', '"b"', '"c"'] - non-lazy, negated
'"a","b","c"'.match(/".*?"/g) # same result with lazy
# When neither works well: use specific character classes
# Match content of <div> (allowing nested non-div tags)
<div\b[^>]*>((?:(?!<div\b)[\s\S])*)<\/div>
# Practical: extract first URL from text
const text = 'visit https://example.com or https://other.com';
const m = text.match(/https?:\/\/[^\s<>"]+/i);
// m[0] = "https://example.com" (greedy on char class, stops at space)
# Use anchored patterns to avoid greediness issues
^.*?word.*$ # lazy doesn't help here - anchored greedy works fine
# Performance: greedy can be FASTER when no backtracking needed
\d+ # greedy but no backtrack issue (concrete chars)
.*?word # lazy to avoid grabbing too muchКатастрофический бэктрекинг
Катастрофический бэктрекинг: вложенные квантификаторы с пересекающимися альтернативами (вроде (a+)+) дают экспоненциальное время на несовпадающих входах. Лечится атомарными группами (?>...), притяжательными квантификаторами (a++), переработкой шаблона без пересечений, таймаутами (Python 3.11+) или движком RE2 (движок Go), который линеен, но не поддерживает обратные ссылки.
# Catastrophic backtracking: exponential time on certain inputs
# Caused by nested quantifiers with overlapping alternatives
# DANGEROUS: (a+)+ on "aaaaaaaaaaaaaaaaaaaaaaa!"
(a+)+ # nested quantifier - exponential backtracking on no-match
# DANGEROUS: overlapping alternatives
(a|a)*b # tries many combinations before failing
# DANGEROUS: classic email regex
([a-zA-Z0-9._%+-]+@([a-zA-Z0-9.-]+\.)+[a-zA-Z]{2,})+
# nested + with alternation can blow up
# How to detect: test with long inputs that DON'T match
# If it hangs on "aaaaaaa...!" - you have it
# Fixes:
# 1. Use atomic groups (PCRE, Java, .NET - NOT JS)
(?>a+)+ # atomic group - no backtracking into group
# 2. Use possessive quantifiers (Java, PCRE - NOT JS)
a++ # possessive - no backtracking
# 3. Refactor: avoid overlapping alternatives
# Bad: (a|a)*b
# Good: a*b
# 4. Be specific with character classes
# Bad: (.*)*
# Good: [a-z]* (or whatever specific chars)
# 5. Use unrolling the loop technique
# Replace (?:a*b*)+ with a*(?:ba*b)* (for example)
# 6. Set a timeout (Python 3.11+)
import re
re.compile(r"(a+)+").match("a" * 30 + "b", timeout=1.0)
# 7. Use RE2 (linear-time engine) in Go, or Google's re2 library
# RE2 doesn't support backreferences but is immune to this issue
# Test your regex at regex101.com - it warns about catastrophic patternsОбратные ссылки
Нумерованные обратные ссылки
Обратные ссылки (\1, \2) совпадают с тем же текстом, что был захвачен ранее. Классика: повторяющиеся слова (\b(\w+)\s+\1\b), парные HTML-теги (<([a-z]+)>...</\1>), парные кавычки, согласованные разделители дат. Обратная ссылка должна совпасть именно с захваченным текстом, а не просто снова с шаблоном.
# \1, \2, ... refer to a PREVIOUSLY captured group's match
# The backreference must match the SAME text the group captured
# Find repeated word
\b(\w+)\s+\1\b
# Matches: "hello hello", "the the", "is is"
# Match HTML/XML tag pairs
<([a-z][a-z0-9]*)\b[^>]*>[\s\S]*?</\1>
# <div>...</div>, <p>...</p>, <span class="x">...</span>
# Match paired quotes (single or double)
(["\'])([^\1]*?)\1
# "hello" or 'hello' - same opening and closing quote
# Date with consistent separator
(\d{4})([-/])(\d{2})\2(\d{2})
# 2024-01-15 OK (same -)
# 2024-01/15 REJECTED (different separators)
# Palindrome-ish: abba
(\w)(\w)\2\1
# JavaScript
"hello hello world".match(/\b(\w+)\s+\1\b/) # ["hello hello", "hello"]
"<div>x</div>".match(/<([a-z]+)>([\s\S]*?)<\/\1>/) # ["<div>x</div>", "div", "x"]
# Python
import re
re.search(r"\b(\w+)\s+\1\b", "hello hello") # match
re.search(r"<([a-z]+)>[\s\S]*?</\1>", "<b>x</b>") # match
# Backreferences in replacement (different from in-pattern backrefs)
"hello".replace(/(\w)/g, "$1$1") # "hheelllloo"Именованные обратные ссылки
Именованные обратные ссылки делают шаблоны самодокументируемыми. JS/.NET/Java используют \k<name>; Python/PCRE — (?P=name). Комбинируйте с именованными группами (?<name>...) для парных тегов, парных разделителей и поиска повторяющихся слов. В замене именованные ссылки: $<name> (JS) или \g<name> (Python).
# Named capture group + named backreference
# JavaScript: (?<name>...) then \k<name>
(?<word>\w+)\s+\k<word>
(?<tag>[a-z]+)>[\s\S]*?</\k<tag>>
# Python: (?P<name>...) then (?P=name)
(?P<word>\w+)\s+(?P=word)
(?P<tag>[a-z]+)>[\s\S]*?</(?P=tag)>
# .NET: (?<name>...) then \k<name> (same as JS)
# Java: (?<name>...) then \k<name>
# PHP/PCRE: (?P<name>...) then (?P=name) or \k<name>
# JavaScript example
const re = /\b(?<word>\w+)\s+\k<word>\b/;
"the the cat".match(re) # ["the the", "the"]
# Python example
import re
re.search(r"(?P<word>\w+)\s+(?P=word)", "hello hello") # match
# Practical: match HTML with named groups
const html = '<div class="x"><span>hi</span></div>';
const re2 = /<(?<tag>[a-z][a-z0-9]*)\b[^>]*>(?<content>[\s\S]*?)<\/\k<tag>>/;
const m = html.match(re2);
// m.groups.tag = "div", m.groups.content = '<span>hi</span>'
# Quote matching with named group
const quoteRe = /(?<q>["\'])[^\k<q>]*\k<q>/g;
'text "hello" and \'world\''.match(quoteRe) # ['"hello"', "\'world\'"]
# Named backref in replacement (JS)
"hello hello".replace(/(?<w>\w+)\s+\k<w>/, "$<w>") # "hello"Повторяющиеся слова
Поиск повторяющихся слов: \b(\w+)\s+\1\b находит удвоения вроде 'the the'. Используйте /i для регистронезависимости. Исправляйте заменой на $1 (JS) или \1 (Python). Варианты: тройные повторы через (\s+\1){2}, только частые слова, исключение допустимых удвоений вроде 'had had' негативным lookahead.
# Find repeated (doubled) words: "the the", "is is"
\b(\w+)\s+\1\b
# Case-insensitive
/\b(\w+)\s+\1\b/i
# JavaScript
const dupRe = /\b(\w+)\s+\1\b/gi;
"I went to the the store and and bought milk".match(dupRe)
# ["the the", "and and"]
# Python
import re
re.findall(r"\b(\w+)\s+\1\b", "the the cat", re.IGNORECASE)
# ["the"]
# Fix doubled words (replace with single)
"I went to the the store".replace(/\b(\w+)\s+\1\b/gi, "$1")
# "I went to the store"
# Python
re.sub(r"\b(\w+)\s+\1\b", r"\1", "the the cat", flags=re.I)
# "the cat"
# Find triple repeats
\b(\w+)(\s+\1){2}\b # "blah blah blah"
# Find any consecutive repeats
\b(\w+)(?:\s+\1)+\b # "blah blah blah blah"
# Limit to specific words
\b(the|and|or|is)\s+\1\b # only common stop words
# Find non-trivial repeats (3+ letters)
\b(\w{3,})\s+\1\b # excludes short words like "is is"
# Skip common valid doubles (very rare in English)
# "had had", "that that" - use negative lookahead to exclude
\b(?!had|that)(\w+)\s+\1\bСопоставление HTML-тегов
Сопоставляйте парные HTML-теги через <([a-z][a-z0-9]*)\b[^>]*>[\s\S]*?</\1> — захватывается имя тега, а обратная ссылка гарантирует совпадение закрывающего. ВНИМАНИЕ: regex НЕ умеет обрабатывать вложенные одноимённые теги (вроде <div><div>x</div></div>) — для вложенного HTML используйте настоящий парсер (DOM в JS, BeautifulSoup в Python).
# Match opening and closing tag with backreference
<([a-z][a-z0-9]*)\b[^>]*>[\s\S]*?</\1>
# <div>...</div>, <span class="x">...</span>
# JavaScript
const html = '<div class="x"><p>hello</p></div>';
const re = /<([a-z][a-z0-9]*)\b[^>]*>([\s\S]*?)<\/\1>/gi;
const m = html.match(re);
// ["<div class="x"><p>hello</p></div>"]
# Iterate over all top-level tags
const re2 = /<([a-z][a-z0-9]*)\b[^>]*>([\s\S]*?)<\/\1>/gi;
let m2;
while ((m2 = re2.exec(html)) !== null) {
console.log(m2[1], m2[2]);
}
# Python
import re
re.findall(r"<([a-z][a-z0-9]*)\b[^>]*>([\s\S]*?)</\1>",
html, re.IGNORECASE)
# [("div", "<p>hello</p>")]
# Self-closing tags
<([a-z][a-z0-9]*)\b[^>]*/>
# Both opening and self-closing
<([a-z][a-z0-9]*)\b[^>]*(?:/>|>[\s\S]*?</\1>)
# Specific tag
<div\b[^>]*>([\s\S]*?)</div>
# WARNING: backreferences can't handle nested same-name tags
# <div><div>x</div></div> - regex can't match outer properly
# Use a parser for nested HTML
# Attribute extraction
<(?<tag>[a-z]+)(?<attrs>[^>]*)>(?<content>[\s\S]*?)</\k<tag>>Сопоставление кавычек
Сопоставляйте строки в кавычках с согласованными разделителями через (['\"])([^\1]*?)\1 — захватывается открывающая кавычка, и требуется та же для закрытия. Для строк с экранированными кавычками (вроде "hello \"world\"") используйте более сложный (['\"])(?:\\.|(?!\1)[^\\])*\1. Наивные шаблоны ломаются на экранированных кавычках.
# Match a quoted string with CONSISTENT quote char
(["\'])([^\1]*?)\1
# "hello" or 'hello' - opening quote remembered, closing must match
# JavaScript
const str = 'She said "hello" and he said \'hi\'';
const re = /(["\'])([^"\']*?)\1/g;
str.match(re) # ['"hello"', "\'hi\'"]
# With named group (clearer)
const re2 = /(?<q>["\'])(?<content>[^\k<q>]*?)\k<q>/g;
# Handle escaped quotes inside
# Allow \" inside double quotes, \' inside single
(["\'])(?:\\.|(?!\1)[^\\])*\1
# "hello \"world\"" matches correctly
# Python
import re
re.findall(r'(["\'])([^\1]*?)\1', 'She said "hello"')
# [('"', 'hello')]
# Practical: extract all quoted strings
text.match(/(["\'])(?:(?!\1).)*\1/g)
# Triple-quoted strings (Python-like)
(?<="""|''')[\s\S]*?\1
# Backtick strings (JS template literals)
`(?:[^\`\\]|\\.)*`
# Replace quoted content
'"hello world"'.replace(/"([^"]*)"/, "[$1]") # "[hello world]"
# WARNING: this naive pattern fails on escaped quotes:
# "hello \"world\"" - the \" ends the match early
# Use the escape-aware version above for productionUnicode в регулярках
Режим Unicode
Режим Unicode необходим для не-ASCII текста: JS использует флаг /u (ES6+), Python 3 по умолчанию Unicode (re.ASCII ограничивает), PHP — /u, Java — Pattern.UNICODE_CHARACTER_CLASS. Без /u в JS суррогатные пары (эмодзи, CJK) обрабатываются неверно — квантификаторы и якоря считают их двумя кодовыми единицами вместо одной.
# JavaScript: /u flag for Unicode mode (ES6+)
/^.$/u.test("𝌆") # true (one code point)
/^.$/.test("𝌆") # false (two UTF-16 code units without /u)
# Without /u: surrogate pairs broken
"𝌆".length # 2 (surrogate pair)
/[\uD834\uDF06]/u.test("𝌆") # true (with /u, treats as one code point)
# Python 3: Unicode is default
import re
re.search(r"\w+", "日本語") # matches (Unicode by default)
# re.ASCII or re.A for ASCII-only
re.search(r"\w+", "日本語", re.ASCII) # ASCII-only, no match
# PHP: /u flag for UTF-8 mode
preg_match('/^.$/u', '𝌆') # 1 (match, treats as one code point)
# Java: Pattern.UNICODE_CHARACTER_CLASS
Pattern p = Pattern.compile("\\w+", Pattern.UNICODE_CHARACTER_CLASS);
# .NET: Unicode by default
# Go (RE2): Unicode by default
# IMPORTANT: /u changes quantifier behavior in JS
/[😂]{2}/u.test("😂😂") # true (quantifier on code point)
/[😂]{2}/.test("😂😂") # unpredictable (code units)
# Case-insensitive Unicode (with /iu)
/\w/iu.test("Ω") # true (Σ/σ/ς equivalence)
# Validate astral plane characters (emoji, ancient scripts)
/^[\u{1F300}-\u{1F9FF}]+$/u # emoji range
/[\u{1F600}-\u{1F64F}]/u # emoticonsЭкранирование свойств \p{...}
Экранирование свойств Unicode (\p{L}, \p{N}, \p{Script=Han}, \p{Emoji}) сопоставляет по свойству символа, а не по диапазону кодовых точек. Гораздо читаемее и надёжнее диапазонов вроде [\u4e00-\u9fff]. В JS требуется флаг /u (ES2018+ для свойств). В Python нужен сторонний модуль 'regex' или Python 3.13+. PHP/Java/.NET/Go поддерживают нативно.
# Unicode property escapes (require /u in JS)
# \p{L} or \p{Letter} - any letter (any script)
/^\p{L}+$/u.test("Hello") # true
/^\p{L}+$/u.test("日本語") # true (CJK letters)
/^\p{L}+$/u.test("Привет") # true (Cyrillic)
# \p{N} or \p{Number} - any number
/^\p{N}+$/u.test("123") # true
/^\p{N}+$/u.test("١٢٣") # true (Arabic-Indic digits)
# \p{P} or \p{Punctuation}
/^\p{P}+$/u.test("!?.") # true
# \p{S} or \p{Symbol}
/^\p{S}+$/u.test("$€¥") # true (currency symbols)
# \p{Z} or \p{Separator} (whitespace including Unicode)
/^\p{Z}+$/u.test(" \u3000") # true (incl. ideographic space)
# Negation: \P{...} (uppercase P)
/^\P{L}+$/u.test("123!") # true (no letters)
# Specific scripts
\p{Script=Han} # CJK characters
\p{Script=Latin} # Latin alphabet
\p{Script=Greek} # Greek
\p{Script=Cyrillic} # Russian etc.
# Categories (long form)
\p{Letter} # same as \p{L}
\p{Lowercase_Letter} # same as \p{Ll}
\p{Uppercase_Letter} # same as \p{Lu}
# Emoji
\p{Emoji} # any emoji character
\p{Emoji_Presentation} # emoji with emoji presentation
# JavaScript support: ES2018+
# Python: needs 'regex' module (PyPI) or Python 3.13+
# PHP: /u flag with \p{L} etc.
# Java: \p{L} (Unicode by default)
# .NET: \p{L} by default
# Go (RE2): \p{L} by defaultСвойство буквы \p{L}
\p{L} совпадает с любой буквой любого письма — латиница, греческий, кириллица, CJK, арабский, иврит и т. д. Подкатегории: \p{Lu} (заглавные), \p{Ll} (строчные), \p{Lo} (прочие — идеограммы CJK, арабский). Используйте \p{L}+ для Unicode-осознанного поиска слов вместо \w+ (по умолчанию только ASCII).
# \p{L} matches any letter in any script
# Match any word (Unicode-aware)
/\p{L}+/gu # matches "hello", "日本語", "Привет"
# Match a single Latin letter
/\p{Script=Latin}/u
# Specific letter categories
\p{Lu} # uppercase letter (A, B, Ω, Ψ)
\p{Ll} # lowercase letter (a, b, ω, ψ)
\p{Lt} # titlecase letter (Dž, Lj - rare)
\p{Lm} # modifier letter (ˆ, ˇ)
\p{Lo} # other letter (CJK, Arabic, Hebrew)
# JavaScript examples
"Hello Ωμέγα".match(/\p{L}+/gu) # ["Hello", "Ωμέγα"]
"hello WORLD".match(/\p{Lu}+/gu) # ["WORLD"]
"Hello".match(/\p{Ll}+/gu) # ["ello"]
# Validate Unicode identifier
/^[\p{L}_][\p{L}\p{N}_]*$/u
# Match Capitalized Unicode word
/\p{Lu}\p{Ll}*/u # "Hello", "Ωμέγα" (if Ω is uppercase)
# Count letters
const text = "Hello 世界 123";
const letters = text.match(/\p{L}/gu) || [];
// ["H", "e", "l", "l", "o", "世", "界"]
# Python (with 'regex' module)
import regex
regex.findall(r"\p{L}+", "Hello 世界")
# Split on non-letters (Unicode-aware)
"hello, world!世界".split(/\P{L}+/u) # ["hello", "world", "世界"]Свойство числа \p{N}
\p{N} совпадает с любым числом: ASCII 0–9, арабо-индийские ٠–٩, деванагари ०–९, римские цифры, дроби. Подкатегории: \p{Nd} (десятичные цифры), \p{Nl} (буквенные числа вроде Ⅷ), \p{No} (прочие вроде ½, ²). Для ASCII используйте явный [0-9]: \d в JS без /u — ASCII, но с /u совпадает с Unicode-цифрами.
# \p{N} matches any number character in any script
# Match digits in any script
\p{N}+ # 123, ١٢٣ (Arabic-Indic), १२३ (Devanagari), etc.
# Subcategories
\p{Nd} # decimal digit (0-9, ٠-٩ Arabic, ०-९ Devanagari)
\p{Nl} # letter number (Roman numerals Ⅷ, etc.)
\p{No} # other number (fractions ½, superscripts ²)
# JavaScript
"Price: 123, Arabic: ١٢٣".match(/\p{N}+/gu)
# ["123", "١٢٣"]
# Match only ASCII digits
/[0-9]/ # ASCII digit
/\d/ # in JS without /u: same as [0-9]
/\d/u # with /u: matches Unicode digits too!
# ASCII-only number (always)
/[0-9]+/
# Match decimals (with optional decimal point)
/\p{N}+(?:\.\p{N}+)?/u
# Count digits (any script)
const text = "123 ١٢٣";
const digits = text.match(/\p{Nd}/gu) || [];
// ["1", "2", "3", "١", "٢", "٣"]
# Python
import regex
regex.findall(r"\p{N}+", "123 ١٢٣")
# Extract version numbers (ASCII only)
const v = "Version 1.2.3 released";
v.match(/[0-9]+(?:\.[0-9]+)+/)[0] # "1.2.3"
# Currency with Unicode digits
/\p{Sc}\p{Nd}+(?:\.\p{Nd}+)?/u # $123.45, €١٢٣.٤٥Сопоставление эмодзи
Сопоставляйте эмодзи через \p{Emoji} (ES2018+ в JS, требуется /u). Частые диапазоны: \u{1F600}-\u{1F64F} (эмотиконы), \u{1F300}-\u{1F5FF} (символы). Настоящее сопоставление эмодзи сложно: ZWJ-последовательности (👨👩👧) объединяют несколько кодовых точек, селекторы вариаций (\uFE0F) меняют отображение, флаги — пары региональных индикаторов. Для полного сопоставления используйте специализированную библиотеку.
# Match emoji (requires /u flag in JS)
# Simple emoji property
/\p{Emoji}/u # any emoji character
/^\p{Emoji}+$/u.test("👋😀🎉") # true
# Emoji with presentation (displayed as emoji, not text)
/\p{Emoji_Presentation}/u
# Common emoji ranges (for older engines without \p{Emoji})
/[\u{1F600}-\u{1F64F}]/u # emoticons
/[\u{1F300}-\u{1F5FF}]/u # symbols & pictographs
/[\u{1F680}-\u{1F6FF}]/u # transport & map
/[\u{1F700}-\u{1F77F}]/u # alchemical
/[\u{2600}-\u{26FF}]/u # misc symbols (☀ ☂ ☎)
/[\u{2700}-\u{27BF}]/u # dingbats (✁ ✂ ✃)
# Combined range
/[\u{1F300}-\u{1F9FF}\u{2600}-\u{27BF}]/u
# Count emoji in text
const text = "Hello 👋😀 world 🎉";
const emoji = text.match(/\p{Emoji}/gu) || [];
// ["👋", "😀", "🎉"]
# Strip emoji from text
text.replace(/\p{Emoji}/gu, "") # "Hello world "
# Emoji with modifiers (skin tones, ZWJ sequences)
# 👨👩👧 is actually multiple code points joined by ZWJ (\u200D)
/\p{Emoji}(?:\u200D\p{Emoji})*/u
# matches a ZWJ sequence as one emoji
# Emoji with variation selector (\uFE0F)
/\p{Emoji}\uFE0F?/u # optional variation selector
# Flag emoji (regional indicators)
/[\u{1F1E6}-\u{1F1FF}]{2}/u # 🇺🇸, 🇨🇳, etc.
# JavaScript support: ES2018+ (\p{Emoji})
# Python: needs 'regex' module
# PHP: /u flag with \p{Emoji}Различия языков
JavaScript
Регулярки в JavaScript: чаще всего литерал /pattern/flags. ES2018+ добавил lookbehind, именованные группы, экранирование свойств Unicode. ES2020+ добавил matchAll (безопаснее, чем /g+exec). Следите за ловушкой lastIndex с /g и exec(). Для динамических шаблонов используйте конструктор RegExp. Экранируйте метасимволы, когда строите шаблон из пользовательского ввода.
# JavaScript regex features
# Literal syntax (preferred for static patterns)
const re = /pattern/flags;
# Constructor (for dynamic patterns)
const re2 = new RegExp("pattern", "flags");
# Flags: g (global), i (case-insensitive), m (multiline),
# s (dotAll, ES2018+), u (Unicode), y (sticky)
# Methods
/pattern/.test(string) # boolean
string.match(/pattern/) # match info or array
string.match(/pattern/g) # array of matches (no groups)
[...string.matchAll(/pattern/g)] # iterator (ES2020+)
string.replace(/pattern/, "repl") # replace first
string.replace(/pattern/g, "repl") # replace all
string.split(/pattern/) # split
string.search(/pattern/) # index of first match or -1
# Named groups (ES2018+)
const m = "2024-01-15".match(/(?<y>\d{4})/);
m.groups.y # "2024"
# Lookbehind (ES2018+, not supported in old Safari)
/(?<=\$)\d+/.test("$100") # true
# Unicode property escapes (ES2018+)
/^\p{L}+$/u.test("Hello") # true
# Gotcha: /g with exec() maintains lastIndex
const r = /a/g;
r.exec("aaa"); r.lastIndex # 1
r.exec("aaa"); r.lastIndex # 2
# Use matchAll or reset lastIndex to 0
# String.prototype.replaceAll (ES2021+)
"a-b-c".replaceAll("-", "+") # "a+b+c"
# Escape function for literal strings
function escapeRegExp(s) {
return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}Python
Модуль re в Python использует сырые строки (r""), чтобы избежать двойного экранирования. Ключевые функции: search (где угодно), match (привязан к началу), fullmatch (вся строка), findall, finditer, sub (замена), split. Синтаксис именованных групп в Python: (?P<name>...) и (?P=name). Python 3.11+ добавляет таймаут для regex. Сторонний модуль 'regex' добавляет свойства \p{...} и рекурсивные шаблоны.
# Python regex (re module)
import re
# Raw strings (r"...") avoid double-escaping
pattern = r"\bword\b"
re.search(pattern, text) # find anywhere
re.match(pattern, text) # anchored at start
re.fullmatch(pattern, text) # entire string
# Flags (constants)
re.IGNORECASE # or re.I - case-insensitive
re.MULTILINE # or re.M - ^ $ match line boundaries
re.DOTALL # or re.S - . matches newline
re.VERBOSE # or re.X - allow whitespace and comments
re.ASCII # or re.A - ASCII-only for \w \d \s
re.UNICODE # default in Python 3
# Combine flags with |
re.search(pattern, text, re.IGNORECASE | re.MULTILINE)
# Inline flags
(?i)pattern # case-insensitive
(?im)pattern # multiple inline flags
(?i:pattern) # scoped (Python 3.6+)
# Common functions
re.search(pattern, string, flags) # Match or None
re.match(pattern, string, flags) # Match or None (anchored)
re.fullmatch(pattern, string) # Match or None (entire)
re.findall(pattern, string) # list of matches or tuples
re.finditer(pattern, string) # iterator of Match objects
re.sub(pattern, repl, string, count=0) # replace
re.split(pattern, string, maxsplit=0) # split
# Named groups (Python-specific syntax)
(?P<name>pattern) # capture
(?P=name) # backreference
\g<name> # in replacement
# Compiled pattern (faster for reuse)
p = re.compile(r"\d+", re.IGNORECASE)
p.search("abc 123")
# Timeout (Python 3.11+)
re.compile(r"(a+)+").match(long_string, timeout=1.0)
# Third-party 'regex' module adds: \p{...}, variable lookbehind, recursJava
В Java regex требует двойного экранирования в строках ("\\d" для \d). Pattern/Matcher разделяют компиляцию и сопоставление. find() переходит к следующему совпадению; matches() требует совпадения всей строки; lookingAt() привязан к началу. Java поддерживает притяжательные квантификаторы (a++) и атомарные группы (?>...). Lookbehind должен быть фиксированной длины. Java 7+ добавила именованные группы.
# Java regex (java.util.regex)
import java.util.regex.*;
# Compile pattern (double-escape backslashes in Java strings)
Pattern p = Pattern.compile("\\bword\\b");
Matcher m = p.matcher("a word here");
# Methods
m.find() # finds next match (boolean)
m.matches() # entire string matches (boolean)
m.lookingAt() # matches at start (boolean)
m.group() # entire match
m.group(1) # first capture group
m.start() # start index
m.end() # end index
# Replace
m.replaceAll("repl") # all matches
m.replaceFirst("repl") # first match only
# String convenience methods (compile internally)
"abc".matches("a.c") # true (entire string)
"a-b-c".replaceAll("-", "+") # "a+b+c" (regex)
"a-b-c".replace("-", "+") # "a+b+c" (literal)
"a-b-c".split("-") # ["a", "b", "c"]
# Flags (constants)
Pattern.CASE_INSENSITIVE # or 1 << 1
Pattern.MULTILINE # or 1 << 2
Pattern.DOTALL # or 1 << 3
Pattern.UNICODE_CHARACTER_CLASS # or 1 << 7
Pattern.COMMENTS # or 1 << 4
# Combine flags with |
Pattern.compile("abc", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE)
# Inline flags
(?i)abc # case-insensitive
(?id)abc # multiple
(?i:abc) # scoped
# Named groups (Java 7+)
(?<name>pattern)
\k<name> # backreference
${name} # in replacement
# Lookbehind: must be FIXED length
(?<=ab|cd)x # OK (same length)
(?<=ab|abc)x # ERROR (different length)
# Possessive quantifiers (Java supports)
a++ a*+ a?+ a{2,5}+
# Atomic groups
(?>a|b)
# Stream matches (Java 9+)
p.matcher(input).results().forEach(m -> ...);PHP (PCRE)
PHP использует PCRE с синтаксисом разделителей (/pattern/flags). Функции: preg_match (одно совпадение), preg_match_all (все), preg_replace, preg_replace_callback, preg_split. Флаги идут после закрывающего разделителя (i, m, s, x, u). Именованные группы: (?P<name>...) или (?<name>...). Используйте флаг /u для UTF-8. Выберите другой разделитель (#, ~), если в шаблоне есть /.
# PHP regex (PCRE - Perl-Compatible Regular Expressions)
# Pattern delimited by / (or other chars like #, ~, |)
/^[a-z]+$/i
'~^[a-z]+$~i'
# Functions
preg_match('/pattern/', $subject) # 0 or 1 (bool-ish)
preg_match('/pattern/', $subject, $matches) # fills $matches
preg_match_all('/pattern/', $subject, $matches) # count, fills $matches
preg_replace('/pattern/', 'repl', $subject) # replace all
preg_replace_callback('/pattern/', fn, $subject) # function replace
preg_split('/pattern/', $subject) # split
# Flags after closing delimiter
i # case-insensitive
m # multiline (^ $ at line boundaries)
s # dotall (. matches newline)
x # extended (whitespace ignored, # comments)
u # treat pattern and subject as UTF-8
# Combine: /pattern/imsu
# $matches structure
preg_match('/(\w+)@(\w+)/', 'user@host', $m);
# $m[0] = "user@host" (whole match)
# $m[1] = "user" (group 1)
# $m[2] = "host" (group 2)
# preg_match_all with PREG_SET_ORDER
preg_match_all('/(\w+)/', 'a b c', $m, PREG_SET_ORDER);
# $m[0] = ["a", "a"], $m[1] = ["b", "b"], ...
# Named groups
/(?P<name>\w+)/ # PHP/PCRE style (also (?<name>...))
/(?<name>\w+)/ # alternative
\k<name> # backreference
$matches['name'] # access by name
# Replacement references
$1, $2 # numbered groups
\1, \2 # also valid
${1} # unambiguous (e.g., ${1}0 to avoid $10)
# Unicode properties (with /u flag)
preg_match('/^\p{L}+$/u', 'Hello')
# PCRE-specific features
(?P<name>...) # named (Python-compatible)
(?<name>...) # named (alternative)
(?P=name) # backreference
(?>...) # atomic group
a++ # possessive
\R # any line break sequence
(*FAIL) # force fail
(*SKIP) # skip in findall
# Delimiter alternatives (when pattern contains /)
# /pattern/, #pattern#, ~pattern~, |pattern|, !pattern!Go (RE2)
Go использует RE2 — линейный движок БЕЗ обратных ссылок, lookbehind, атомарных групп и притяжательных квантификаторов. Взамен RE2 не подвержен катастрофическому бэктрекингу. Методы: MatchString (bool), FindString (первое), FindAllString (все), ReplaceAllString, Split. Используйте сырые строки (обратные кавычки), чтобы избежать двойного экранирования. Флаги только встроенные: (?i), (?m), (?s).
# Go regex (RE2 engine - linear time, no backreferences)
import "regexp"
# Compile pattern (must use raw string `...` or escape backslashes)
re := regexp.MustCompile(`\bword\b`)
re := regexp.MustCompile("\\bword\\b") # with escaping
# Methods
re.MatchString("a word here") # bool
re.FindString("a word here") # first match or ""
re.FindAllString("a b c", -1) # []string of all matches
re.FindStringSubmatch("user@host") # [whole, group1, group2, ...]
re.FindAllStringSubmatch(text, -1) # [][]string
re.FindStringIndex("abc") # [start, end] or nil
re.ReplaceAllString("a-b-c", "+") # "a+b+c"
re.ReplaceAllStringFunc(text, func)
re.Split("a,b,c", -1) # []string
# -1 means "all matches"; positive N limits splits/matches
# Named groups
re := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})`)
m := re.FindStringSubmatch("2024-01")
# m[0]="2024-01", m[1]="2024", m[2]="01"
# Access by name
re.SubexpNames() # ["", "year", "month"]
# IMPORTANT: RE2 limitations
# - NO backreferences (\1)
# - NO atomic groups (?>...)
# - NO possessive quantifiers (a++)
# - NO lookbehind (?<=...)
# - NO lookahead (?!...) — but (?=...) IS supported
# - NO recursive patterns
# - NO conditional patterns
# In exchange: linear-time guarantee (no catastrophic backtracking)
# Flags (inline only — no separate flags arg)
(?i) # case-insensitive
(?m) # multiline
(?s) # dotall
(?i)pattern # applies to whole pattern
(?i)abc(?-i)def # scoped (PCRE-style, not in Go)
# Compile vs MustCompile
re, err := regexp.Compile(pattern) # returns error
re := regexp.MustCompile(pattern) # panics on error
# Quote literal string for safe regex use
regexp.QuoteMeta("1.5") # "1\\.5".NET / C#
.NET regex богат возможностями: именованные группы (?<name>...), балансирующие группы (уникально — умеют сопоставлять вложенные структуры вроде сбалансированных скобок), таймауты, MatchEvaluator для замены функцией. Используйте verbatim-строки (@""), чтобы избежать двойного экранирования. RegexOptions.Singleline означает dotall (сбивающее имя). .NET поддерживает больше возможностей regex, чем любой другой крупный движок.
# .NET regex (System.Text.RegularExpressions)
using System.Text.RegularExpressions;
# Static methods
Regex.IsMatch("abc", "a.c") # bool
Regex.Match("abc", "a.c") # first match
Regex.Matches("a1 b2", "\d+") # all matches
Regex.Replace("a-b-c", "-", "+") # "a+b+c"
Regex.Split("a,b,c", ",") # string[]
# Instance (compiled for reuse)
Regex re = new Regex("\\d+", RegexOptions.Compiled);
re.Match("abc 123");
re.Matches("abc 123 456");
re.Replace("abc 123", "X");
# Flags (RegexOptions enum)
RegexOptions.IgnoreCase # i
RegexOptions.Multiline # m
RegexOptions.Singleline # s (dotall - confusing name!)
RegexOptions.ExplicitCapture # only named groups capture
RegexOptions.IgnorePatternWhitespace # x (extended)
RegexOptions.Compiled # compile to IL (faster, slower startup)
RegexOptions.CultureInvariant
# Combine with |
new Regex("abc", RegexOptions.IgnoreCase | RegexOptions.Multiline)
# Named groups (.NET style)
(?<name>pattern) # capture
(?<name1>...) (?<name2>...) # multiple
\k<name> # backreference
${name} # in replacement
# Alternation in group names (balancing groups - .NET specific)
(?<name1-name2>...) # pop name2 stack into name1
# Group access
Match m = re.Match("2024-01-15");
m.Groups["year"].Value
m.Groups[1].Value
# Replace with MatchEvaluator (function)
Regex.Replace("abc", "\w", m => m.Value.ToUpper()) # "ABC"
# Timeouts (.NET 4.5+)
Regex re = new Regex("a+", RegexOptions.None, TimeSpan.FromSeconds(1));
# Unicode supported by default
Regex.IsMatch("Hello", @"\p{L}+") # true (note: @"" verbatim string)
# Verbatim strings (@"...") avoid double-escaping
@"\d+" # same as "\\d+" but cleaner
# Surprisingly powerful: balancing groups for nested matching
# Can match balanced parentheses (unique to .NET)
@"((?:[^()]+|(?<Open>\()|(?<Close-Open>\)))*)"Продвинутые техники
Атомарные группы
Атомарные группы (?>...) запрещают бэктрекинг внутрь группы после совпадения. Полезны для производительности (избегают катастрофического бэктрекинга) и фиксации совпадений. Поддерживаются в PCRE, Java, .NET и модуле 'regex' Python — НЕ в JavaScript. Альтернатива в JS: переработать шаблон или использовать конкретные классы символов, чтобы избежать бэктрекинга.
# Atomic group: (?>...) - once matched, NO backtracking into it
# Supported in PCRE, Java, .NET — NOT in JavaScript or Python's re
# Greedy with backtracking
\d+a # in "123a", \d+ takes "123", then backtracks to "12" if needed
(?>\d+)a # atomic: \d+ takes "123" and CANNOT give back
# When atomic helps: prevent catastrophic backtracking
# Dangerous: (a+)+b on "aaaa...!"
# Safe (atomic): (?>a+)+b or (?>a+b)
# Use case: prevent unwanted backtracking in alternation
# Without atomic: tries each alternative, backtracks on fail
(?>cat|category) # if "cat" matches, won't try "category"
# Practical: match HTML tag without backtracking issues
(?><[a-z][a-z0-9]*\b[^>]*>)
# Quoted string without backtracking issues
(?>"[^"]*")
# Java
Pattern p = Pattern.compile("(?>\\d+)a");
# PHP/PCRE
preg_match('/(?>\d+)a/', '123a')
# .NET
new Regex("(?>\d+)a")
# Python: not in re module; use 'regex' module
import regex
regex.search(r"(?>\d+)a", "123a")
# JavaScript: NOT supported
# Use possessive quantifiers (also not in JS) or refactor patternПритяжательные квантификаторы
Притяжательные квантификаторы (a++, a*+, a?+) похожи на жадные, но никогда не отдают совпадения обратно. Эквивалентны атомарным группам, но короче. Поддерживаются в Java и PCRE — НЕ в .NET, JavaScript и re в Python. Используйте атомарные группы (?>...) как переносимую альтернативу. Оба варианта предотвращают катастрофический бэктрекинг за счёт отказа от лишних откатов.
# Possessive: a++ a*+ a?+ a{n,m}+
# Like greedy but NEVER gives back (no backtracking)
# Greedy (gives back if needed)
\d+a # "123a": \d+ takes "123", matches a
\d+x # "123x": \d+ takes "123", then x matches
# Possessive (never gives back)
\d++a # "123a": \d+ takes "123", matches a
\d++x # "123x": \d+ takes "123", x fails - NO backtrack, FAIL
# When possessive helps: avoid catastrophic backtracking
# Dangerous: (a+)+ on "aaaaaa!"
# Possessive: (a++)+ or (?>a+)+
# Both prevent exponential backtracking
# Common possessive patterns
"[^"]*"++ # possessive quoted string
<[a-z]++> # possessive tag name
\d++\.\d++ # possessive decimal
# Java supports possessive quantifiers
Pattern.compile("\\d++a");
# PHP/PCRE supports possessive
preg_match('/\d++a/', '123a')
# .NET: does NOT support possessive quantifiers directly
# Use atomic groups instead: (?>\d+)a
# Python 're': NOT supported
# Python 'regex' module: supports \d++ ? Actually no, use (?>\d+)
# JavaScript: NOT supported
# Use atomic groups (also not in JS) or refactor
# Comparison: possessive vs atomic
\d++ # possessive quantifier (Java, PCRE)
(?>\d+) # atomic group (Java, PCRE, .NET)
# Both prevent backtracking; possessive is shorter syntaxУсловные шаблоны
Условные шаблоны (?(condition)yes|no) сопоставляют разные шаблоны в зависимости от того, совпала ли группа или сработал ли lookahead. Поддерживаются в PCRE, .NET, Perl и модуле 'regex' Python — НЕ в JavaScript и Java. Обходной путь в неподдерживающих движках: альтернация, несколько шаблонов в коде или lookaround.
# Conditional: (?(condition)yes-pattern|no-pattern)
# PCRE, .NET, Perl — NOT JavaScript or Python's re
# Conditional based on group match
(?(1)yes|no) # if group 1 matched, use yes-pattern; else no-pattern
(?(<name>)yes|no) # named group version
# Example: match "Mr. Smith" or "Smith" based on title presence
(Mr\.\s+)?(\w+)(?(1)\s+\2|) # if title, require last name repeated?
# Practical: optional separator
# If first separator was -, second must be -
# If first was /, second must be /
(\d{4})([-/]?)(\d{2})(?(2)\2|[-/]?)(\d{2})
# Conditional based on lookahead
(?(?=\d)\d+|[a-z]+) # if next is digit, match digits; else letters
# Python 'regex' module supports conditionals
import regex
regex.search(r"(?(1)yes|no)", text)
# .NET supports conditionals
new Regex("(?(1)yes|no)")
# PCRE/PHP supports conditionals
preg_match('/(?(1)yes|no)/', $text)
# Java: does NOT support conditionals directly
# Use alternation and lookarounds as workaround
# JavaScript: NOT supported
# Refactor with alternation:
# (?(1)A|B) becomes: (?:group1A|B) in some cases
# Or use two separate patterns and combine in code
# Real-world: parse key-value where value is conditional
# If key is "url", value must be URL; if "count", value must be number
(url|count):(?(?<=url:)https?://\S+|\d+)Рекурсия (PCRE)
Рекурсивные шаблоны (?R) сопоставляют вложенные структуры вроде сбалансированных скобок, вложенного HTML или математических выражений. PCRE/Perl и модуль 'regex' Python поддерживают это напрямую. .NET использует уникальные «балансирующие группы». JavaScript и Java НЕ поддерживают рекурсию regex — для вложенных структур используйте парсер или стек.
# Recursive patterns: (?R) or (?N) - match nested structures
# PCRE, Perl, .NET (balancing groups) — NOT JS, Java, Python re
# Match balanced parentheses (PCRE)
\((?:[^()]+|(?R))*\)
# Matches: "(a)", "(a(b)c)", "((a)(b))", etc.
# Named recursion (PCRE)
(?<paren>\((?:[^()]+|(?&paren))*\))
# Match nested HTML/XML tags (PCRE)
(?<tag><([a-z]+)(?:[^>]+)>[^<]*</\2>|<([a-z]+)(?:[^>]+)>(?R)*</\3>)
# Python 'regex' module supports recursion
import regex
regex.search(r"\((?:[^()]+|(?R))*\)", "(a(b)c)")
# .NET: use balancing groups instead of recursion
# Match balanced parens:
\((?:[^()]+|(?<Open>\()|(?<Close-Open>\)))*\)
# More complex but powerful
# PHP/PCRE
preg_match('/\((?:[^()]+|(?R))*\)/', '(a(b)c)')
# JavaScript: NOT supported
# Use a parser or stack-based approach in code
function matchBalanced(s) {
let depth = 0, start = -1, results = [];
for (let i = 0; i < s.length; i++) {
if (s[i] === "(") { if (depth === 0) start = i; depth++; }
else if (s[i] === ")") {
depth--;
if (depth === 0 && start !== -1) {
results.push(s.slice(start, i + 1));
start = -1;
}
}
}
return results;
}
# Java: NOT supported
# Use third-party library or stack-based parserСоветы по производительности
Производительность regex: компилируйте шаблоны для повторного использования, будьте конкретны (избегайте .), по возможности ставьте якоря, используйте незахватывающие группы, избегайте катастрофического бэктрекинга, предпочитайте отрицательные классы ленивым квантификаторам, сортируйте альтернацию по вероятности, задавайте таймауты для недоверенного ввода. Используйте методы строк (trim, split, indexOf), когда их достаточно, — они часто быстрее regex.
# 1. Compile patterns for reuse (Python, Java)
import re
p = re.compile(r"\d+") # compile once
for line in lines:
p.search(line) # reuse
# 2. Be specific - avoid . when you know the char class
# Bad: .*
# Good: [a-z]* or \w* or [^,]*
# Faster and clearer intent
# 3. Anchor when possible
# Bad: \d+
# Good: ^\d+$ (if validating entire string)
# Anchors let the engine fail fast
# 4. Use non-capturing groups when you don't need captures
# Bad: (\d{1,3}\.){3}\d{1,3}
# Good: (?:\d{1,3}\.){3}\d{1,3}
# Saves memory and time
# 5. Avoid catastrophic backtracking
# Bad: (a+)+b on "aaaa...!"
# Good: a++b (possessive) or (?>a+)b (atomic) or a*b
# 6. Prefer negated classes over lazy quantifiers for delimited content
# Slower: ".*?"
# Faster: "[^"]*"
# 7. Use atomic groups / possessive quantifiers when safe
(?>\d+) # no backtracking needed for digits
# 8. Order alternation by likelihood
# Bad: (rare|common)
# Good: (common|rare)
# Engine tries left to right
# 9. Avoid nested quantifiers on overlapping alternatives
# Bad: (a|a)*b
# Good: a*b
# 10. Set timeouts for untrusted input (Python 3.11+, .NET 4.5+)
re.compile(pattern).match(input, timeout=1.0)
# 11. Use RE2 for untrusted patterns (Go, or libraries)
# Linear time, immune to catastrophic backtracking
# Trade-off: no backreferences
# 12. Benchmark with realistic data
# Use timeit (Python) or performance.now() (JS)
# 13. Avoid lookahead/lookbehind when a simpler pattern works
# Bad: (?<=\$)\d+
# Good: \$(\d+) and use group 1 (often faster)
# 14. Use String methods for simple operations
# Bad: text.replace(/^\s+|\s+$/g, "")
# Good: text.trim() (much faster)Связанные сниппеты Regex
Copy-paste ready code for common tasks.
Character Classes
Match sets and ranges of characters.
Quantifiers
Control how many times a token repeats.
Groups and Capturing
Capture, non-capture, and named groups.
Lookaround
Zero-width assertions around a position.
Alternation
Match one of several branches.
Anchors
Match positions instead of characters.
Backreferences
Reuse a previously captured group.
Common Patterns
Practical patterns for everyday validation.
Was this helpful?